Intravision/reactos
1
0
Fork 0
mirror of https://github.com/reactos/reactos.git synced 2025-05-03 04:35:38 +00:00
Code Issues Projects Releases Packages Wiki Activity

[MSHTML]

Browse source 
sync mshtml to wine 1.1.40

svn path=/trunk/; revision=45918
This commit is contained in:
Christoph von Wittich 2010-03-06 11:42:03 +00:00
parent 701bf7b07f
commit d25edac691
12 changed files with 770 additions and 631 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

3
reactos/dll/win32/mshtml/htmldoc.c
View file

@ -1776,6 +1776,9 @@ static BOOL htmldoc_qi(HTMLDocument *This, REFIID riid, void **ppv)
}else if(IsEqualGUID(&IID_IExternalConnection, riid)) {
TRACE("(%p)->(IID_IExternalConnection %p) returning NULL\n", This, ppv);
*ppv = NULL;
}else if(IsEqualGUID(&IID_IStdMarshalInfo, riid)) {
TRACE("(%p)->(IID_IStdMarshalInfo %p) returning NULL\n", This, ppv);
*ppv = NULL;
}else if(IsEqualGUID(&IID_IObjectWithSite, riid)) {
TRACE("(%p)->(IID_IObjectWithSite %p)\n", This, ppv);
*ppv = OBJSITE(This);

14
reactos/dll/win32/mshtml/htmlscript.c
View file

@ -214,8 +214,18 @@ static HRESULT WINAPI HTMLScriptElement_get_onerror(IHTMLScriptElement *iface, V
static HRESULT WINAPI HTMLScriptElement_put_type(IHTMLScriptElement *iface, BSTR v)
{
HTMLScriptElement *This = HTMLSCRIPT_THIS(iface);
FIXME("(%p)->(%s)\n", This, debugstr_w(v));
return E_NOTIMPL;
nsAString nstype_str;
nsresult nsres;
TRACE("(%p)->(%s)\n", This, debugstr_w(v));
nsAString_Init(&nstype_str, v);
nsres = nsIDOMHTMLScriptElement_SetType(This->nsscript, &nstype_str);
if (NS_FAILED(nsres))
ERR("SetType failed: %08x\n", nsres);
nsAString_Finish (&nstype_str);
return S_OK;
}
static HRESULT WINAPI HTMLScriptElement_get_type(IHTMLScriptElement *iface, BSTR *p)

166
reactos/dll/win32/mshtml/htmlwindow.c
View file

@ -1,5 +1,5 @@
/*
* Copyright 2006 Jacek Caban for CodeWeavers
* Copyright 2006-2010 Jacek Caban for CodeWeavers
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
@ -25,9 +25,9 @@
#include "winuser.h"
#include "ole2.h"
#include "mshtmdid.h"
#include "shlguid.h"
#include "wine/debug.h"
#include "wine/unicode.h"
#include "mshtml_private.h"
#include "htmlevent.h"
@ -35,6 +35,8 @@
WINE_DEFAULT_DEBUG_CHANNEL(mshtml);
#define HTMLPRIVWINDOW(x) ((IHTMLPrivateWindow*) &(x)->lpIHTMLPrivateWindowVtbl)
static struct list window_list = LIST_INIT(window_list);
static void window_set_docnode(HTMLWindow *window, HTMLDocumentNode *doc_node)
@ -166,6 +168,9 @@ static HRESULT WINAPI HTMLWindow2_QueryInterface(IHTMLWindow2 *iface, REFIID rii
}else if(IsEqualGUID(&IID_IHTMLWindow4, riid)) {
TRACE("(%p)->(IID_IHTMLWindow4 %p)\n", This, ppv);
*ppv = HTMLWINDOW4(This);
}else if(IsEqualGUID(&IID_IHTMLPrivateWindow, riid)) {
TRACE("(%p)->(IID_IHTMLPrivateWindow %p)\n", This, ppv);
*ppv = HTMLPRIVWINDOW(This);
}else if(dispex_query_interface(&This->dispex, riid, ppv)) {
return *ppv ? S_OK : E_NOINTERFACE;
}
@ -1641,6 +1646,162 @@ static const IHTMLWindow4Vtbl HTMLWindow4Vtbl = {
HTMLWindow4_get_frameElement
};
#define HTMLPRIVWINDOW_THIS(iface) DEFINE_THIS(HTMLWindow, IHTMLPrivateWindow, iface)
static HRESULT WINAPI HTMLPrivateWindow_QueryInterface(IHTMLPrivateWindow *iface, REFIID riid, void **ppv)
{
HTMLWindow *This = HTMLPRIVWINDOW_THIS(iface);
return IHTMLWindow2_QueryInterface(HTMLWINDOW2(This), riid, ppv);
}
static ULONG WINAPI HTMLPrivateWindow_AddRef(IHTMLPrivateWindow *iface)
{
HTMLWindow *This = HTMLPRIVWINDOW_THIS(iface);
return IHTMLWindow2_AddRef(HTMLWINDOW2(This));
}
static ULONG WINAPI HTMLPrivateWindow_Release(IHTMLPrivateWindow *iface)
{
HTMLWindow *This = HTMLPRIVWINDOW_THIS(iface);
return IHTMLWindow2_Release(HTMLWINDOW2(This));
}
static HRESULT WINAPI HTMLPrivateWindow_SuperNavigate(IHTMLPrivateWindow *iface, BSTR url, BSTR arg2, BSTR arg3,
BSTR arg4, VARIANT *post_data_var, VARIANT *headers_var, ULONG flags)
{
HTMLWindow *This = HTMLPRIVWINDOW_THIS(iface);
DWORD post_data_size = 0;
BYTE *post_data = NULL;
WCHAR *headers = NULL;
nsChannelBSC *bsc;
IMoniker *mon;
BSTR new_url;
HRESULT hres;
TRACE("(%p)->(%s %s %s %s %s %s %x)\n", This, debugstr_w(url), debugstr_w(arg2), debugstr_w(arg3), debugstr_w(arg4),
debugstr_variant(post_data_var), debugstr_variant(headers_var), flags);
new_url = url;
if(This->doc_obj->hostui) {
OLECHAR *translated_url = NULL;
hres = IDocHostUIHandler_TranslateUrl(This->doc_obj->hostui, 0, url, &translated_url);
if(hres == S_OK && translated_url) {
new_url = SysAllocString(translated_url);
CoTaskMemFree(translated_url);
}
}
if(This->doc_obj->client) {
IOleCommandTarget *cmdtrg;
hres = IOleClientSite_QueryInterface(This->doc_obj->client, &IID_IOleCommandTarget, (void**)&cmdtrg);
if(SUCCEEDED(hres)) {
VARIANT in, out;
V_VT(&in) = VT_BSTR;
V_BSTR(&in) = new_url;
V_VT(&out) = VT_BOOL;
V_BOOL(&out) = VARIANT_TRUE;
hres = IOleCommandTarget_Exec(cmdtrg, &CGID_ShellDocView, 67, 0, &in, &out);
IOleCommandTarget_Release(cmdtrg);
if(SUCCEEDED(hres))
VariantClear(&out);
}
}
/* FIXME: Why not set_ready_state? */
This->readystate = READYSTATE_UNINITIALIZED;
hres = CreateURLMoniker(NULL, new_url, &mon);
if(new_url != url)
SysFreeString(new_url);
if(FAILED(hres))
return hres;
if(post_data_var) {
if(V_VT(post_data_var) == (VT_ARRAY|VT_UI1)) {
SafeArrayAccessData(V_ARRAY(post_data_var), (void**)&post_data);
post_data_size = V_ARRAY(post_data_var)->rgsabound[0].cElements;
}
}
if(headers_var && V_VT(headers_var) != VT_EMPTY && V_VT(headers_var) != VT_ERROR) {
if(V_VT(headers_var) != VT_BSTR)
return E_INVALIDARG;
headers = V_BSTR(headers_var);
}
hres = create_channelbsc(mon, headers, post_data, post_data_size, &bsc);
if(post_data)
SafeArrayUnaccessData(V_ARRAY(post_data_var));
if(FAILED(hres)) {
IMoniker_Release(mon);
return hres;
}
hres = set_moniker(&This->doc_obj->basedoc, mon, NULL, bsc, TRUE);
if(SUCCEEDED(hres))
hres = async_start_doc_binding(This, bsc);
IUnknown_Release((IUnknown*)bsc);
IMoniker_Release(mon);
return hres;
}
static HRESULT WINAPI HTMLPrivateWindow_GetPendingUrl(IHTMLPrivateWindow *iface, BSTR *url)
{
HTMLWindow *This = HTMLPRIVWINDOW_THIS(iface);
FIXME("(%p)->(%p)\n", This, url);
return E_NOTIMPL;
}
static HRESULT WINAPI HTMLPrivateWindow_SetPICSTarget(IHTMLPrivateWindow *iface, IOleCommandTarget *cmdtrg)
{
HTMLWindow *This = HTMLPRIVWINDOW_THIS(iface);
FIXME("(%p)->(%p)\n", This, cmdtrg);
return E_NOTIMPL;
}
static HRESULT WINAPI HTMLPrivateWindow_PICSComplete(IHTMLPrivateWindow *iface, int arg)
{
HTMLWindow *This = HTMLPRIVWINDOW_THIS(iface);
FIXME("(%p)->(%x)\n", This, arg);
return E_NOTIMPL;
}
static HRESULT WINAPI HTMLPrivateWindow_FindWindowByName(IHTMLPrivateWindow *iface, LPCWSTR name, IHTMLWindow2 **ret)
{
HTMLWindow *This = HTMLPRIVWINDOW_THIS(iface);
FIXME("(%p)->(%s %p)\n", This, debugstr_w(name), ret);
return E_NOTIMPL;
}
static HRESULT WINAPI HTMLPrivateWindow_GetAddressBar(IHTMLPrivateWindow *iface, BSTR *url)
{
HTMLWindow *This = HTMLPRIVWINDOW_THIS(iface);
FIXME("(%p)->(%p)\n", This, url);
return E_NOTIMPL;
}
#undef HTMLPRIVWINDOW_THIS
static const IHTMLPrivateWindowVtbl HTMLPrivateWindowVtbl = {
HTMLPrivateWindow_QueryInterface,
HTMLPrivateWindow_AddRef,
HTMLPrivateWindow_Release,
HTMLPrivateWindow_SuperNavigate,
HTMLPrivateWindow_GetPendingUrl,
HTMLPrivateWindow_SetPICSTarget,
HTMLPrivateWindow_PICSComplete,
HTMLPrivateWindow_FindWindowByName,
HTMLPrivateWindow_GetAddressBar
};
#define DISPEX_THIS(iface) DEFINE_THIS(HTMLWindow, IDispatchEx, iface)
static HRESULT WINAPI WindowDispEx_QueryInterface(IDispatchEx *iface, REFIID riid, void **ppv)
@ -1954,6 +2115,7 @@ HRESULT HTMLWindow_Create(HTMLDocumentObj *doc_obj, nsIDOMWindow *nswindow, HTML
window->lpHTMLWindow2Vtbl = &HTMLWindow2Vtbl;
window->lpHTMLWindow3Vtbl = &HTMLWindow3Vtbl;
window->lpHTMLWindow4Vtbl = &HTMLWindow4Vtbl;
window->lpIHTMLPrivateWindowVtbl = &HTMLPrivateWindowVtbl;
window->lpIDispatchExVtbl = &WindowDispExVtbl;
window->ref = 1;
window->doc_obj = doc_obj;

24
reactos/dll/win32/mshtml/mshtml_private.h
View file

@ -172,9 +172,11 @@ BOOL dispex_query_interface(DispatchEx*,REFIID,void**);
HRESULT dispex_get_dprop_ref(DispatchEx*,const WCHAR*,BOOL,VARIANT**);
HRESULT get_dispids(tid_t,DWORD*,DISPID**);
typedef struct HTMLWindow HTMLWindow;
typedef struct HTMLDocumentNode HTMLDocumentNode;
typedef struct HTMLDocumentObj HTMLDocumentObj;
typedef struct HTMLFrameBase HTMLFrameBase;
typedef struct NSContainer NSContainer;
typedef enum {
SCRIPTMODE_GECKO,
@ -226,11 +228,14 @@ typedef struct {
LONG ref;
} windowref_t;
typedef struct nsChannelBSC nsChannelBSC;
struct HTMLWindow {
DispatchEx dispex;
const IHTMLWindow2Vtbl *lpHTMLWindow2Vtbl;
const IHTMLWindow3Vtbl *lpHTMLWindow3Vtbl;
const IHTMLWindow4Vtbl *lpHTMLWindow4Vtbl;
const IHTMLPrivateWindowVtbl *lpIHTMLPrivateWindowVtbl;
const IDispatchExVtbl *lpIDispatchExVtbl;
LONG ref;
@ -393,7 +398,7 @@ struct HTMLDocumentObj {
BOOL in_place_active;
BOOL ui_active;
BOOL window_active;
BOOL has_key_path;
BOOL hostui_setup;
BOOL container_locked;
BOOL focus;
INT download_state;
@ -434,6 +439,11 @@ struct NSContainer {
HWND reset_focus; /* hack */
};
typedef struct nsWineURI nsWineURI;
HRESULT set_wine_url(nsWineURI*,LPCWSTR);
nsresult on_start_uri_open(NSContainer*,nsIURI*,PRBool*);
typedef struct {
const nsIHttpChannelVtbl *lpHttpChannelVtbl;
const nsIUploadChannelVtbl *lpUploadChannelVtbl;
@ -441,7 +451,7 @@ typedef struct {
LONG ref;
nsIWineURI *uri;
nsWineURI *uri;
nsIInputStream *post_data_stream;
nsILoadGroup *load_group;
nsIInterfaceRequestor *notif_callback;
@ -696,12 +706,13 @@ void release_nsio(void);
BOOL install_wine_gecko(BOOL);
HRESULT nsuri_to_url(LPCWSTR,BOOL,BSTR*);
HRESULT create_doc_uri(HTMLWindow*,WCHAR*,nsIWineURI**);
HRESULT create_doc_uri(HTMLWindow*,WCHAR*,nsWineURI**);
HRESULT load_nsuri(HTMLWindow*,nsWineURI*,nsChannelBSC*,DWORD);
HRESULT hlink_frame_navigate(HTMLDocument*,LPCWSTR,nsIInputStream*,DWORD);
HRESULT hlink_frame_navigate(HTMLDocument*,LPCWSTR,nsIInputStream*,DWORD,BOOL*);
HRESULT navigate_url(HTMLWindow*,const WCHAR*,const WCHAR*);
HRESULT set_frame_doc(HTMLFrameBase*,nsIDOMDocument*);
HRESULT load_nsuri(HTMLWindow*,nsIWineURI*,DWORD);
HRESULT set_moniker(HTMLDocument*,IMoniker*,IBindCtx*,nsChannelBSC*,BOOL);
void call_property_onchanged(ConnectionPoint*,DISPID);
HRESULT call_set_active_object(IOleInPlaceUIWindow*,IOleInPlaceActiveObject*);
@ -730,11 +741,12 @@ void add_nsevent_listener(HTMLDocumentNode*,LPCWSTR);
void set_window_bscallback(HTMLWindow*,nsChannelBSC*);
void set_current_mon(HTMLWindow*,IMoniker*);
HRESULT start_binding(HTMLWindow*,HTMLDocumentNode*,BSCallback*,IBindCtx*);
HRESULT async_start_doc_binding(HTMLWindow*,nsChannelBSC*);
void abort_document_bindings(HTMLDocumentNode*);
HRESULT bind_mon_to_buffer(HTMLDocumentNode*,IMoniker*,void**,DWORD*);
nsChannelBSC *create_channelbsc(IMoniker*);
HRESULT create_channelbsc(IMoniker*,WCHAR*,BYTE*,DWORD,nsChannelBSC**);
HRESULT channelbsc_load_stream(nsChannelBSC*,IStream*);
void channelbsc_set_channel(nsChannelBSC*,nsChannel*,nsIStreamListener*,nsISupports*);
IMoniker *get_channelbsc_mon(nsChannelBSC*);

153
reactos/dll/win32/mshtml/navigate.c
View file

@ -717,8 +717,11 @@ HRESULT start_binding(HTMLWindow *window, HTMLDocumentNode *doc, BSCallback *bsc
/* NOTE: IE7 calls IsSystemMoniker here*/
if(window)
if(window) {
if(bscallback->mon != window->mon)
set_current_mon(window, bscallback->mon);
call_docview_84(window->doc_obj);
}
if(bctx) {
RegisterBindStatusCallback(bctx, STATUSCLB(bscallback), NULL, 0);
@ -1087,7 +1090,7 @@ static HRESULT nsChannelBSC_on_progress(BSCallback *bsc, ULONG status_code, LPCW
TRACE("redirect to %s\n", debugstr_w(status_text));
/* FIXME: We should find a better way to handle this */
nsIWineURI_SetWineURL(This->nschannel->uri, status_text);
set_wine_url(This->nschannel->uri, status_text);
}
return S_OK;
@ -1113,13 +1116,38 @@ static const BSCallbackVtbl nsChannelBSCVtbl = {
nsChannelBSC_on_response
};
nsChannelBSC *create_channelbsc(IMoniker *mon)
HRESULT create_channelbsc(IMoniker *mon, WCHAR *headers, BYTE *post_data, DWORD post_data_size, nsChannelBSC **retval)
{
nsChannelBSC *ret = heap_alloc_zero(sizeof(*ret));
nsChannelBSC *ret;
ret = heap_alloc_zero(sizeof(*ret));
if(!ret)
return E_OUTOFMEMORY;
init_bscallback(&ret->bsc, &nsChannelBSCVtbl, mon, BINDF_ASYNCHRONOUS | BINDF_ASYNCSTORAGE | BINDF_PULLDATA);
return ret;
if(headers) {
ret->bsc.headers = heap_strdupW(headers);
if(!ret->bsc.headers) {
IBindStatusCallback_Release(STATUSCLB(&ret->bsc));
return E_OUTOFMEMORY;
}
}
if(post_data) {
ret->bsc.post_data = GlobalAlloc(0, post_data_size);
if(!ret->bsc.post_data) {
heap_free(ret->bsc.headers);
IBindStatusCallback_Release(STATUSCLB(&ret->bsc));
return E_OUTOFMEMORY;
}
memcpy(ret->bsc.post_data, post_data, post_data_size);
ret->bsc.post_data_len = post_data_size;
}
*retval = ret;
return S_OK;
}
IMoniker *get_channelbsc_mon(nsChannelBSC *This)
@ -1148,6 +1176,36 @@ void set_window_bscallback(HTMLWindow *window, nsChannelBSC *callback)
}
}
typedef struct {
task_t header;
HTMLWindow *window;
nsChannelBSC *bscallback;
} start_doc_binding_task_t;
static void start_doc_binding_proc(task_t *_task)
{
start_doc_binding_task_t *task = (start_doc_binding_task_t*)_task;
start_binding(task->window, NULL, (BSCallback*)task->bscallback, NULL);
IBindStatusCallback_Release(STATUSCLB(&task->bscallback->bsc));
}
HRESULT async_start_doc_binding(HTMLWindow *window, nsChannelBSC *bscallback)
{
start_doc_binding_task_t *task;
task = heap_alloc(sizeof(start_doc_binding_task_t));
if(!task)
return E_OUTOFMEMORY;
task->window = window;
task->bscallback = bscallback;
IBindStatusCallback_AddRef(STATUSCLB(&bscallback->bsc));
push_task(&task->header, start_doc_binding_proc, window->task_magic);
return S_OK;
}
void abort_document_bindings(HTMLDocumentNode *doc)
{
BSCallback *iter;
@ -1196,37 +1254,43 @@ void channelbsc_set_channel(nsChannelBSC *This, nsChannel *channel, nsIStreamLis
}
HRESULT hlink_frame_navigate(HTMLDocument *doc, LPCWSTR url,
nsIInputStream *post_data_stream, DWORD hlnf)
nsIInputStream *post_data_stream, DWORD hlnf, BOOL *cancel)
{
IHlinkFrame *hlink_frame;
nsChannelBSC *callback;
IServiceProvider *sp;
BSCallback *callback;
IBindCtx *bindctx;
IMoniker *mon;
IHlink *hlink;
HRESULT hres;
*cancel = FALSE;
hres = IOleClientSite_QueryInterface(doc->doc_obj->client, &IID_IServiceProvider,
(void**)&sp);
if(FAILED(hres))
return hres;
return S_OK;
hres = IServiceProvider_QueryService(sp, &IID_IHlinkFrame, &IID_IHlinkFrame,
(void**)&hlink_frame);
IServiceProvider_Release(sp);
if(FAILED(hres))
return S_OK;
hres = create_channelbsc(NULL, NULL, NULL, 0, &callback);
if(FAILED(hres)) {
IHlinkFrame_Release(hlink_frame);
return hres;
callback = &create_channelbsc(NULL)->bsc;
if(post_data_stream) {
parse_post_data(post_data_stream, &callback->headers, &callback->post_data,
&callback->post_data_len);
TRACE("headers = %s post_data = %s\n", debugstr_w(callback->headers),
debugstr_an(callback->post_data, callback->post_data_len));
}
hres = CreateAsyncBindCtx(0, STATUSCLB(callback), NULL, &bindctx);
if(post_data_stream) {
parse_post_data(post_data_stream, &callback->bsc.headers, &callback->bsc.post_data,
&callback->bsc.post_data_len);
TRACE("headers = %s post_data = %s\n", debugstr_w(callback->bsc.headers),
debugstr_an(callback->bsc.post_data, callback->bsc.post_data_len));
}
hres = CreateAsyncBindCtx(0, STATUSCLB(&callback->bsc), NULL, &bindctx);
if(SUCCEEDED(hres))
hres = CoCreateInstance(&CLSID_StdHlink, NULL, CLSCTX_INPROC_SERVER,
&IID_IHlink, (LPVOID*)&hlink);
@ -1242,50 +1306,22 @@ HRESULT hlink_frame_navigate(HTMLDocument *doc, LPCWSTR url,
IHlink_SetTargetFrameName(hlink, wszBlank); /* FIXME */
}
hres = IHlinkFrame_Navigate(hlink_frame, hlnf, bindctx, STATUSCLB(callback), hlink);
hres = IHlinkFrame_Navigate(hlink_frame, hlnf, bindctx, STATUSCLB(&callback->bsc), hlink);
IMoniker_Release(mon);
*cancel = hres == S_OK;
hres = S_OK;
}
IHlinkFrame_Release(hlink_frame);
IBindCtx_Release(bindctx);
IBindStatusCallback_Release(STATUSCLB(callback));
IBindStatusCallback_Release(STATUSCLB(&callback->bsc));
return hres;
}
HRESULT load_nsuri(HTMLWindow *window, nsIWineURI *uri, DWORD flags)
{
nsIWebNavigation *web_navigation;
nsIDocShell *doc_shell;
nsresult nsres;
nsres = get_nsinterface((nsISupports*)window->nswindow, &IID_nsIWebNavigation, (void**)&web_navigation);
if(NS_FAILED(nsres)) {
ERR("Could not get nsIWebNavigation interface: %08x\n", nsres);
return E_FAIL;
}
nsres = nsIWebNavigation_QueryInterface(web_navigation, &IID_nsIDocShell, (void**)&doc_shell);
nsIWebNavigation_Release(web_navigation);
if(NS_FAILED(nsres)) {
ERR("Could not get nsIDocShell: %08x\n", nsres);
return E_FAIL;
}
nsres = nsIDocShell_LoadURI(doc_shell, (nsIURI*)uri, NULL, flags, FALSE);
nsIDocShell_Release(doc_shell);
if(NS_FAILED(nsres)) {
WARN("LoadURI failed: %08x\n", nsres);
return E_FAIL;
}
return S_OK;
}
HRESULT navigate_url(HTMLWindow *window, const WCHAR *new_url, const WCHAR *base_url)
{
WCHAR url[INTERNET_MAX_URL_LENGTH];
nsIWineURI *uri;
nsWineURI *uri;
HRESULT hres;
if(!new_url) {
@ -1307,23 +1343,30 @@ HRESULT navigate_url(HTMLWindow *window, const WCHAR *new_url, const WCHAR *base
hres = IDocHostUIHandler_TranslateUrl(window->doc_obj->hostui, 0, url,
&translated_url);
if(hres == S_OK) {
TRACE("%08x %s -> %s\n", hres, debugstr_w(url), debugstr_w(translated_url));
strcpyW(url, translated_url);
CoTaskMemFree(translated_url);
}
}
if(window->doc_obj && window == window->doc_obj->basedoc.window) {
hres = hlink_frame_navigate(&window->doc->basedoc, url, NULL, 0);
if(SUCCEEDED(hres))
BOOL cancel;
hres = hlink_frame_navigate(&window->doc->basedoc, url, NULL, 0, &cancel);
if(FAILED(hres))
return hres;
if(cancel) {
TRACE("Navigation handled by hlink frame\n");
return S_OK;
TRACE("hlink_frame_navigate failed: %08x\n", hres);
}
}
hres = create_doc_uri(window, url, &uri);
if(FAILED(hres))
return hres;
hres = load_nsuri(window, uri, LOAD_FLAGS_NONE);
nsIWineURI_Release(uri);
hres = load_nsuri(window, uri, NULL, LOAD_FLAGS_NONE);
nsISupports_Release((nsISupports*)uri);
return hres;
}

48
reactos/dll/win32/mshtml/nsembed.c
View file

@ -1124,41 +1124,12 @@ static nsrefcnt NSAPI nsURIContentListener_Release(nsIURIContentListener *iface)
return nsIWebBrowserChrome_Release(NSWBCHROME(This));
}
static BOOL translate_url(HTMLDocumentObj *doc, nsIWineURI *nsuri)
{
OLECHAR *new_url = NULL, *url;
BOOL ret = FALSE;
LPCWSTR wine_url;
HRESULT hres;
if(!doc->hostui)
return FALSE;
nsIWineURI_GetWineURL(nsuri, &wine_url);
url = heap_strdupW(wine_url);
hres = IDocHostUIHandler_TranslateUrl(doc->hostui, 0, url, &new_url);
heap_free(url);
if(hres != S_OK || !new_url)
return FALSE;
if(strcmpW(url, new_url)) {
FIXME("TranslateUrl returned new URL %s -> %s\n", debugstr_w(url), debugstr_w(new_url));
ret = TRUE;
}
CoTaskMemFree(new_url);
return ret;
}
static nsresult NSAPI nsURIContentListener_OnStartURIOpen(nsIURIContentListener *iface,
nsIURI *aURI, PRBool *_retval)
{
NSContainer *This = NSURICL_THIS(iface);
nsIWineURI *wine_uri;
nsACString spec_str;
const char *spec;
BOOL is_doc_uri;
nsresult nsres;
nsACString_Init(&spec_str, NULL);
@ -1169,22 +1140,9 @@ static nsresult NSAPI nsURIContentListener_OnStartURIOpen(nsIURIContentListener
nsACString_Finish(&spec_str);
nsres = nsIURI_QueryInterface(aURI, &IID_nsIWineURI, (void**)&wine_uri);
if(NS_FAILED(nsres)) {
WARN("Could not get nsIWineURI interface: %08x\n", nsres);
return NS_ERROR_NOT_IMPLEMENTED;
}
nsIWineURI_GetIsDocumentURI(wine_uri, &is_doc_uri);
if(!is_doc_uri) {
nsIWineURI_SetNSContainer(wine_uri, This);
nsIWineURI_SetIsDocumentURI(wine_uri, TRUE);
*_retval = translate_url(This->doc->basedoc.doc_obj, wine_uri);
}
nsIWineURI_Release(wine_uri);
nsres = on_start_uri_open(This, aURI, _retval);
if(NS_FAILED(nsres))
return nsres;
return !*_retval && This->content_listener
? nsIURIContentListener_OnStartURIOpen(This->content_listener, aURI, _retval)

29
reactos/dll/win32/mshtml/nsiface.idl
View file

@ -2820,32 +2820,3 @@ interface nsIDocumentObserver : nsIMutationObserver
void BindToDocument(nsIDocument *aDocument, nsIContent *aContent);
void DoneAddingChildren(nsIContent *aContent, PRBool aHaveNotified);
}
/*
* NOTE:
* This is a private Wine interface that is implemented by our implementation
* of nsIURI to store its owner.
*/
[
object,
uuid(5088272e-900b-11da-c687-000fea57f21a),
local
/* INTERNAL */
]
interface nsIWineURI : nsIURL
{
typedef struct NSContainer NSContainer;
typedef struct HTMLWindow HTMLWindow;
typedef struct nsChannelBSC nsChannelBSC;
nsresult GetNSContainer(NSContainer **aNSContainer);
nsresult SetNSContainer(NSContainer *aNSContainer);
nsresult GetWindow(HTMLWindow **aHTMLWindow);
nsresult SetWindow(HTMLWindow *aHTMLWindow);
nsresult GetChannelBSC(nsChannelBSC **aChannelBSC);
nsresult SetChannelBSC(nsChannelBSC *aChannelBSC);
nsresult GetIsDocumentURI(PRBool *aIsDocumentURI);
nsresult SetIsDocumentURI(PRBool aIsDocumentURI);
nsresult GetWineURL(LPCWSTR *aURL);
nsresult SetWineURL(LPCWSTR aURL);
}

756
reactos/dll/win32/mshtml/nsio.c
View file

File diff suppressed because it is too large Load diff

17
reactos/dll/win32/mshtml/oleobj.c
View file

@ -34,9 +34,13 @@
#include "wine/debug.h"
#include "mshtml_private.h"
#include "initguid.h"
WINE_DEFAULT_DEBUG_CHANNEL(mshtml);
DEFINE_OLEGUID(CGID_DocHostCmdPriv, 0x000214D4L, 0, 0);
#define DOCHOST_DOCCANNAVIGATE 0
/**********************************************************
* IOleObject implementation
*/
@ -92,6 +96,7 @@ static HRESULT WINAPI OleObject_SetClientSite(IOleObject *iface, IOleClientSite
HTMLDocument *This = OLEOBJ_THIS(iface);
IDocHostUIHandler *pDocHostUIHandler = NULL;
IOleCommandTarget *cmdtrg = NULL;
BOOL hostui_setup;
VARIANT silent;
HRESULT hres;
@ -116,6 +121,8 @@ static HRESULT WINAPI OleObject_SetClientSite(IOleObject *iface, IOleClientSite
if(!pClientSite)
return S_OK;
hostui_setup = This->doc_obj->hostui_setup;
hres = IOleObject_QueryInterface(pClientSite, &IID_IDocHostUIHandler, (void**)&pDocHostUIHandler);
if(SUCCEEDED(hres)) {
DOCHOSTUIINFO hostinfo;
@ -133,7 +140,7 @@ static HRESULT WINAPI OleObject_SetClientSite(IOleObject *iface, IOleClientSite
This->doc_obj->hostinfo = hostinfo;
}
if(!This->doc_obj->has_key_path) {
if(!hostui_setup) {
hres = IDocHostUIHandler_GetOptionKeyPath(pDocHostUIHandler, &key_path, 0);
if(hres == S_OK && key_path) {
if(key_path[0]) {
@ -157,7 +164,7 @@ static HRESULT WINAPI OleObject_SetClientSite(IOleObject *iface, IOleClientSite
IDocHostUIHandler2_Release(pDocHostUIHandler2);
}
This->doc_obj->has_key_path = TRUE;
This->doc_obj->hostui_setup = TRUE;
}
}
@ -179,6 +186,12 @@ static HRESULT WINAPI OleObject_SetClientSite(IOleObject *iface, IOleClientSite
VARIANT var;
OLECMD cmd = {OLECMDID_SETPROGRESSTEXT, 0};
if(!hostui_setup) {
V_VT(&var) = VT_UNKNOWN;
V_UNKNOWN(&var) = (IUnknown*)HTMLWINDOW2(This->window);
IOleCommandTarget_Exec(cmdtrg, &CGID_DocHostCmdPriv, DOCHOST_DOCCANNAVIGATE, 0, &var, NULL);
}
IOleCommandTarget_QueryStatus(cmdtrg, NULL, 1, &cmd, NULL);
V_VT(&var) = VT_I4;

154
reactos/dll/win32/mshtml/persist.c
View file

@ -155,6 +155,9 @@ static void set_downloading_proc(task_t *_task)
doc->download_state = 1;
}
if(doc->view_sink)
IAdviseSink_OnViewChange(doc->view_sink, DVASPECT_CONTENT, -1);
if(doc->hostui) {
IDropTarget *drop_target = NULL;
@ -166,50 +169,15 @@ static void set_downloading_proc(task_t *_task)
}
}
static HRESULT set_moniker(HTMLDocument *This, IMoniker *mon, IBindCtx *pibc, BOOL set_download)
HRESULT set_moniker(HTMLDocument *This, IMoniker *mon, IBindCtx *pibc, nsChannelBSC *async_bsc, BOOL set_download)
{
nsChannelBSC *bscallback;
LPOLESTR url = NULL;
docobj_task_t *task;
download_proc_task_t *download_task;
nsIWineURI *nsuri;
nsWineURI *nsuri;
LPOLESTR url;
HRESULT hres;
if(pibc) {
IUnknown *unk = NULL;
/* FIXME:
* Use params:
* "__PrecreatedObject"
* "BIND_CONTEXT_PARAM"
* "__HTMLLOADOPTIONS"
* "__DWNBINDINFO"
* "URL Context"
* "CBinding Context"
* "_ITransData_Object_"
* "_EnumFORMATETC_"
*/
IBindCtx_GetObjectParam(pibc, (LPOLESTR)SZ_HTML_CLIENTSITE_OBJECTPARAM, &unk);
if(unk) {
IOleClientSite *client = NULL;
hres = IUnknown_QueryInterface(unk, &IID_IOleClientSite, (void**)&client);
if(SUCCEEDED(hres)) {
TRACE("Got client site %p\n", client);
IOleObject_SetClientSite(OLEOBJ(This), client);
IOleClientSite_Release(client);
}
IUnknown_Release(unk);
}
}
set_ready_state(This->window, READYSTATE_LOADING);
update_doc(This, UPDATE_TITLE);
HTMLDocument_LockContainer(This->doc_obj, TRUE);
hres = IMoniker_GetDisplayName(mon, pibc, NULL, &url);
if(FAILED(hres)) {
WARN("GetDiaplayName failed: %08x\n", hres);
@ -218,11 +186,8 @@ static HRESULT set_moniker(HTMLDocument *This, IMoniker *mon, IBindCtx *pibc, BO
TRACE("got url: %s\n", debugstr_w(url));
set_current_mon(This->window, mon);
if(This->doc_obj->client) {
VARIANT silent, offline;
IOleCommandTarget *cmdtrg = NULL;
hres = get_client_disp_property(This->doc_obj->client, DISPID_AMBIENT_SILENT, &silent);
if(SUCCEEDED(hres)) {
@ -240,15 +205,37 @@ static HRESULT set_moniker(HTMLDocument *This, IMoniker *mon, IBindCtx *pibc, BO
else if(V_BOOL(&silent))
FIXME("offline == true\n");
}
}
if(This->window->mon) {
update_doc(This, UPDATE_TITLE|UPDATE_UI);
}else {
update_doc(This, UPDATE_TITLE);
set_current_mon(This->window, mon);
}
set_ready_state(This->window, READYSTATE_LOADING);
if(This->doc_obj->client) {
IOleCommandTarget *cmdtrg = NULL;
hres = IOleClientSite_QueryInterface(This->doc_obj->client, &IID_IOleCommandTarget,
(void**)&cmdtrg);
if(SUCCEEDED(hres)) {
VARIANT var;
VARIANT var, out;
V_VT(&var) = VT_I4;
V_I4(&var) = 0;
IOleCommandTarget_Exec(cmdtrg, &CGID_ShellDocView, 37, 0, &var, NULL);
if(!async_bsc) {
V_VT(&var) = VT_I4;
V_I4(&var) = 0;
IOleCommandTarget_Exec(cmdtrg, &CGID_ShellDocView, 37, 0, &var, NULL);
}else {
V_VT(&var) = VT_UNKNOWN;
V_UNKNOWN(&var) = (IUnknown*)HTMLWINDOW2(This->window);
V_VT(&out) = VT_EMPTY;
hres = IOleCommandTarget_Exec(cmdtrg, &CGID_ShellDocView, 63, 0, &var, &out);
if(SUCCEEDED(hres))
VariantClear(&out);
}
IOleCommandTarget_Release(cmdtrg);
}
@ -259,17 +246,25 @@ static HRESULT set_moniker(HTMLDocument *This, IMoniker *mon, IBindCtx *pibc, BO
if(FAILED(hres))
return hres;
bscallback = create_channelbsc(mon);
if(async_bsc) {
bscallback = async_bsc;
}else {
hres = create_channelbsc(mon, NULL, NULL, 0, &bscallback);
if(FAILED(hres))
return hres;
}
nsIWineURI_SetChannelBSC(nsuri, bscallback);
hres = load_nsuri(This->window, nsuri, LOAD_INITIAL_DOCUMENT_URI);
nsIWineURI_SetChannelBSC(nsuri, NULL);
hres = load_nsuri(This->window, nsuri, bscallback, LOAD_INITIAL_DOCUMENT_URI);
nsISupports_Release((nsISupports*)nsuri); /* FIXME */
if(SUCCEEDED(hres))
set_window_bscallback(This->window, bscallback);
IUnknown_Release((IUnknown*)bscallback);
if(bscallback != async_bsc)
IUnknown_Release((IUnknown*)bscallback);
if(FAILED(hres))
return hres;
HTMLDocument_LockContainer(This->doc_obj, TRUE);
if(This->doc_obj->frame) {
task = heap_alloc(sizeof(docobj_task_t));
task->doc = This->doc_obj;
@ -375,7 +370,36 @@ static HRESULT WINAPI PersistMoniker_Load(IPersistMoniker *iface, BOOL fFullyAva
TRACE("(%p)->(%x %p %p %08x)\n", This, fFullyAvailable, pimkName, pibc, grfMode);
hres = set_moniker(This, pimkName, pibc, TRUE);
if(pibc) {
IUnknown *unk = NULL;
/* FIXME:
* Use params:
* "__PrecreatedObject"
* "BIND_CONTEXT_PARAM"
* "__HTMLLOADOPTIONS"
* "__DWNBINDINFO"
* "URL Context"
* "_ITransData_Object_"
* "_EnumFORMATETC_"
*/
IBindCtx_GetObjectParam(pibc, (LPOLESTR)SZ_HTML_CLIENTSITE_OBJECTPARAM, &unk);
if(unk) {
IOleClientSite *client = NULL;
hres = IUnknown_QueryInterface(unk, &IID_IOleClientSite, (void**)&client);
if(SUCCEEDED(hres)) {
TRACE("Got client site %p\n", client);
IOleObject_SetClientSite(OLEOBJ(This), client);
IOleClientSite_Release(client);
}
IUnknown_Release(unk);
}
}
hres = set_moniker(This, pimkName, pibc, NULL, TRUE);
if(FAILED(hres))
return hres;
@ -636,7 +660,7 @@ static HRESULT WINAPI PersistStreamInit_Load(IPersistStreamInit *iface, LPSTREAM
return hres;
}
hres = set_moniker(This, mon, NULL, TRUE);
hres = set_moniker(This, mon, NULL, NULL, TRUE);
IMoniker_Release(mon);
if(FAILED(hres))
return hres;
@ -682,44 +706,24 @@ static HRESULT WINAPI PersistStreamInit_InitNew(IPersistStreamInit *iface)
{
HTMLDocument *This = PERSTRINIT_THIS(iface);
IMoniker *mon;
HGLOBAL body;
LPSTREAM stream;
HRESULT hres;
static const WCHAR about_blankW[] = {'a','b','o','u','t',':','b','l','a','n','k',0};
static const WCHAR html_bodyW[] = {'<','H','T','M','L','>','<','/','H','T','M','L','>',0};
TRACE("(%p)\n", This);
body = GlobalAlloc(0, sizeof(html_bodyW));
if(!body)
return E_OUTOFMEMORY;
memcpy(body, html_bodyW, sizeof(html_bodyW));
hres = CreateURLMoniker(NULL, about_blankW, &mon);
if(FAILED(hres)) {
WARN("CreateURLMoniker failed: %08x\n", hres);
GlobalFree(body);
return hres;
}
hres = set_moniker(This, mon, NULL, FALSE);
hres = set_moniker(This, mon, NULL, NULL, FALSE);
IMoniker_Release(mon);
if(FAILED(hres)) {
GlobalFree(body);
if(FAILED(hres))
return hres;
}
hres = CreateStreamOnHGlobal(body, TRUE, &stream);
if(FAILED(hres)) {
GlobalFree(body);
return hres;
}
hres = channelbsc_load_stream(This->window->bscallback, stream);
IStream_Release(stream);
return hres;
return start_binding(This->window, NULL, (BSCallback*)This->window->bscallback, NULL);
}
#undef PERSTRINIT_THIS

17
reactos/dll/win32/mshtml/rsrc.rc
View file

@ -35,28 +35,31 @@
#include "Bg.rc"
#include "Da.rc"
#include "De.rc"
#include "En.rc"
#include "Es.rc"
#include "Fi.rc"
#include "Fr.rc"
#include "Hu.rc"
#include "Ko.rc"
#include "Nl.rc"
#include "Pl.rc"
#include "Sv.rc"
#include "Tr.rc"
/* UTF-8 */
#include "De.rc"
#include "Fr.rc"
#include "It.rc"
#include "Ja.rc"
#include "Ko.rc"
#include "Lt.rc"
#include "Nl.rc"
#include "No.rc"
#include "Pl.rc"
#include "Pt.rc"
#include "Ro.rc"
#include "Ru.rc"
#include "Si.rc"
#include "Sv.rc"
#include "Tr.rc"
#include "Uk.rc"
#include "Zh.rc"
LANGUAGE LANG_NEUTRAL, SUBLANG_NEUTRAL
/* @makedep: mshtml.inf */

20
reactos/include/psdk/mshtml.idl
View file

@ -15407,3 +15407,23 @@ interface IElementBehaviorFactory : IUnknown
}
} /* library MSHTML */
interface IOleCommandTarget;
/*****************************************************************************
* IHTMLPrivateWindow interface
*/
[
object,
uuid(3050f6dc-98b5-11cf-bb82-00aa00bdce0b),
local
]
interface IHTMLPrivateWindow : IUnknown
{
HRESULT SuperNavigate(BSTR url, BSTR arg2, BSTR arg3, BSTR arg4, VARIANT *post_data, VARIANT *headers, ULONG flags);
HRESULT GetPendingUrl(BSTR *url);
HRESULT SetPICSTarget(IOleCommandTarget *cmdtrg);
HRESULT PICSComplete(int arg);
HRESULT FindWindowByName(LPCWSTR name, IHTMLWindow2 **ret);
HRESULT GetAddressBarUrl(BSTR *url);
}