Intravision/reactos
1
0
Fork 0
mirror of https://github.com/reactos/reactos.git synced 2025-02-23 00:45:24 +00:00
Code Issues Projects Releases Packages Wiki Activity

[MSHTML] Sync with Wine Staging 1.7.37. CORE-9246

Browse source 
[BOOTDATA][APPWIZ][GECKO] Update to version 2.34.

svn path=/trunk/; revision=66928
This commit is contained in:
Amine Khaldi 2015-03-28 15:51:47 +00:00
parent ed9dd50f5b
commit 1974d5fbfa
62 changed files with 5835 additions and 4218 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
reactos/boot/bootdata/packages/reactos.dff.in
View file

@ -105,7 +105,7 @@ Signature = "$ReactOS$"
"modules/optional/vmx_mode.dll" 1 optional
"modules/optional/vmx_svga.inf" 6 optional
"modules/optional/vmx_svga.sys" 2 optional
"modules/optional/wine_gecko-2.24-x86.msi" 4 optional
"modules/optional/wine_gecko-2.34-x86.msi" 4 optional
"boot/bootdata/bootcdregtest/AHKAppTests.cmd" 7 optional
"modules/optional/gnutls/libgcc_s_sjlj-1.dll" 53 optional
"modules/optional/gnutls/libgmp-10.dll" 53 optional

6
reactos/dll/cpl/appwiz/addons.c
View file

@ -26,11 +26,11 @@
#include <msi.h>
#define GECKO_VERSION "2.24"
#define GECKO_VERSION "2.34"
#ifdef __i386__
#define ARCH_STRING "x86"
#define GECKO_SHA "f6984567b24fef7b0be79837e04d3a913af1a88c"
#define GECKO_SHA "330100fecc9c12e98760fd5abfbf3e3d0cccf052"
#else
#define ARCH_STRING ""
#define GECKO_SHA "???"
@ -60,7 +60,7 @@ static const addon_info_t *addon;
static HWND install_dialog = NULL;
static WCHAR GeckoUrl[] = L"http://svn.reactos.org/amine/wine_gecko-2.24-x86.msi";
static WCHAR GeckoUrl[] = L"http://svn.reactos.org/amine/wine_gecko-2.34-x86.msi";
/* SHA definitions are copied from advapi32. They aren't available in headers. */

2
reactos/dll/win32/mshtml/CMakeLists.txt
View file

@ -22,8 +22,6 @@ list(APPEND SOURCE
htmlcurstyle.c
htmldoc.c
htmlelem.c
htmlelem2.c
htmlelem3.c
htmlelemcol.c
htmlembed.c
htmlevent.c

32
reactos/dll/win32/mshtml/binding.h
View file

@ -27,6 +27,12 @@ typedef enum {
METHOD_POST
} REQUEST_METHOD;
typedef enum {
BOM_NONE,
BOM_UTF8,
BOM_UTF16
} binding_bom_t;
typedef struct {
nsIHttpChannel nsIHttpChannel_iface;
nsIUploadChannel nsIUploadChannel_iface;
@ -40,6 +46,7 @@ typedef struct {
nsILoadGroup *load_group;
nsIInterfaceRequestor *notif_callback;
nsISupports *owner;
nsILoadInfo *load_info;
nsLoadFlags load_flags;
nsIURI *original_uri;
nsIURI *referrer;
@ -52,6 +59,7 @@ typedef struct {
} nsChannel;
typedef struct {
nsIInputStream *post_stream;
WCHAR *headers;
HGLOBAL post_data;
ULONG post_data_len;
@ -73,7 +81,7 @@ struct BSCallback {
ULONG readed;
DWORD bindf;
BOOL bindinfo_ready;
int bom;
binding_bom_t bom;
IMoniker *mon;
IBinding *binding;
@ -98,6 +106,17 @@ struct nsChannelBSC {
nsProtocolStream *nsstream;
};
struct BSCallbackVtbl {
void (*destroy)(BSCallback*);
HRESULT (*init_bindinfo)(BSCallback*);
HRESULT (*start_binding)(BSCallback*);
HRESULT (*stop_binding)(BSCallback*,HRESULT);
HRESULT (*read_data)(BSCallback*,IStream*);
HRESULT (*on_progress)(BSCallback*,ULONG,LPCWSTR);
HRESULT (*on_response)(BSCallback*,DWORD,LPCWSTR);
HRESULT (*beginning_transaction)(BSCallback*,WCHAR**);
};
typedef struct {
struct list entry;
WCHAR *header;
@ -117,25 +136,26 @@ HRESULT create_redirect_nschannel(const WCHAR*,nsChannel*,nsChannel**) DECLSPEC_
nsresult on_start_uri_open(NSContainer*,nsIURI*,cpp_bool*) DECLSPEC_HIDDEN;
HRESULT hlink_frame_navigate(HTMLDocument*,LPCWSTR,nsChannel*,DWORD,BOOL*) DECLSPEC_HIDDEN;
HRESULT create_doc_uri(HTMLOuterWindow*,IUri*,nsWineURI**) DECLSPEC_HIDDEN;
HRESULT load_nsuri(HTMLOuterWindow*,nsWineURI*,nsChannelBSC*,DWORD) DECLSPEC_HIDDEN;
HRESULT load_nsuri(HTMLOuterWindow*,nsWineURI*,nsIInputStream*,nsChannelBSC*,DWORD) DECLSPEC_HIDDEN;
HRESULT set_moniker(HTMLOuterWindow*,IMoniker*,IUri*,IBindCtx*,nsChannelBSC*,BOOL) DECLSPEC_HIDDEN;
void prepare_for_binding(HTMLDocument*,IMoniker*,DWORD) DECLSPEC_HIDDEN;
HRESULT super_navigate(HTMLOuterWindow*,IUri*,DWORD,const WCHAR*,BYTE*,DWORD) DECLSPEC_HIDDEN;
HRESULT load_uri(HTMLOuterWindow*,IUri*,DWORD) DECLSPEC_HIDDEN;
HRESULT navigate_new_window(HTMLOuterWindow*,IUri*,const WCHAR*,IHTMLWindow2**) DECLSPEC_HIDDEN;
HRESULT navigate_new_window(HTMLOuterWindow*,IUri*,const WCHAR*,request_data_t*,IHTMLWindow2**) DECLSPEC_HIDDEN;
HRESULT navigate_url(HTMLOuterWindow*,const WCHAR*,IUri*,DWORD) DECLSPEC_HIDDEN;
HRESULT submit_form(HTMLOuterWindow*,IUri*,nsIInputStream*) DECLSPEC_HIDDEN;
HRESULT submit_form(HTMLOuterWindow*,const WCHAR*,IUri*,nsIInputStream*) DECLSPEC_HIDDEN;
void init_bscallback(BSCallback*,const BSCallbackVtbl*,IMoniker*,DWORD) DECLSPEC_HIDDEN;
HRESULT create_channelbsc(IMoniker*,const WCHAR*,BYTE*,DWORD,BOOL,nsChannelBSC**) DECLSPEC_HIDDEN;
HRESULT channelbsc_load_stream(HTMLInnerWindow*,IMoniker*,IStream*) DECLSPEC_HIDDEN;
void channelbsc_set_channel(nsChannelBSC*,nsChannel*,nsIStreamListener*,nsISupports*) DECLSPEC_HIDDEN;
IUri *nsuri_get_uri(nsWineURI*) DECLSPEC_HIDDEN;
HRESULT read_stream(BSCallback*,IStream*,void*,DWORD,DWORD*) DECLSPEC_HIDDEN;
HRESULT create_relative_uri(HTMLOuterWindow*,const WCHAR*,IUri**) DECLSPEC_HIDDEN;
HRESULT create_uri(const WCHAR*,DWORD,IUri**) DECLSPEC_HIDDEN;
IUri *get_uri_nofrag(IUri*) DECLSPEC_HIDDEN;
void set_current_mon(HTMLOuterWindow*,IMoniker*,DWORD) DECLSPEC_HIDDEN;
void set_current_uri(HTMLOuterWindow*,IUri*) DECLSPEC_HIDDEN;
HRESULT bind_mon_to_wstr(HTMLInnerWindow*,IMoniker*,WCHAR**) DECLSPEC_HIDDEN;

208
reactos/dll/win32/mshtml/dispex.c
View file

@ -72,7 +72,7 @@ typedef struct {
typedef struct {
func_disp_t *func_obj;
IDispatch *val;
VARIANT val;
} func_obj_entry_t;
struct dispex_dynamic_data_t {
@ -215,9 +215,15 @@ static void add_func_info(dispex_data_t *data, DWORD *size, tid_t tid, const FUN
func_info_t *info;
HRESULT hres;
if(data->func_cnt && data->funcs[data->func_cnt-1].id == desc->memid) {
info = data->funcs+data->func_cnt-1;
}else {
for(info = data->funcs; info < data->funcs+data->func_cnt; info++) {
if(info->id == desc->memid) {
if(info->tid != tid)
return; /* Duplicated in other interface */
break;
}
}
if(info == data->funcs+data->func_cnt) {
if(data->func_cnt == *size)
data->funcs = heap_realloc_zero(data->funcs, (*size <<= 1)*sizeof(func_info_t));
@ -324,9 +330,18 @@ static dispex_data_t *preprocess_dispex_data(DispatchEx *This)
}
data = heap_alloc(sizeof(dispex_data_t));
if (!data) {
ERR("Out of memory\n");
return NULL;
}
data->func_cnt = 0;
data->func_disp_cnt = 0;
data->funcs = heap_alloc_zero(size*sizeof(func_info_t));
if (!data->funcs) {
heap_free (data);
ERR("Out of memory\n");
return NULL;
}
list_add_tail(&dispex_data_list, &data->entry);
while(*tid) {
@ -358,22 +373,6 @@ static dispex_data_t *preprocess_dispex_data(DispatchEx *This)
data->funcs = heap_realloc(data->funcs, data->func_cnt * sizeof(func_info_t));
qsort(data->funcs, data->func_cnt, sizeof(func_info_t), dispid_cmp);
for(i = 1; i < data->func_cnt && data->funcs[i-1].id != data->funcs[i].id; i++);
if(i < data->func_cnt) {
unsigned j = i--;
/* We have at least one duplicated property. This may happen if more than one
* interface implements the same property. We have to remove these duplicated
* entries. */
while(j < data->func_cnt) {
while(j+1 < data->func_cnt && data->funcs[j+1].id == data->funcs[j].id)
j++;
data->funcs[i++] = data->funcs[j++];
}
data->func_cnt = i;
}
data->name_table = heap_alloc(data->func_cnt * sizeof(func_info_t*));
for(i=0; i < data->func_cnt; i++)
data->name_table[i] = data->funcs+i;
@ -635,8 +634,9 @@ static HRESULT WINAPI Function_QueryInterface(IUnknown *iface, REFIID riid, void
{
func_disp_t *This = impl_from_IUnknown(iface);
TRACE("(%p)->(%s %p)\n", This, debugstr_mshtml_guid(riid), ppv);
if(IsEqualGUID(&IID_IUnknown, riid)) {
TRACE("(%p)->(IID_IUnknown %p)\n", This, ppv);
*ppv = &This->IUnknown_iface;
}else if(dispex_query_interface(&This->dispex, riid, ppv)) {
return *ppv ? S_OK : E_NOINTERFACE;
@ -818,6 +818,7 @@ static HRESULT invoke_disp_value(DispatchEx *This, IDispatch *func_disp, LCID lc
static HRESULT get_func_obj_entry(DispatchEx *This, func_info_t *func, func_obj_entry_t **ret)
{
dispex_dynamic_data_t *dynamic_data;
func_obj_entry_t *entry;
dynamic_data = get_dynamic_data(This);
if(!dynamic_data)
@ -829,20 +830,18 @@ static HRESULT get_func_obj_entry(DispatchEx *This, func_info_t *func, func_obj_
return E_OUTOFMEMORY;
}
if(!dynamic_data->func_disps[func->func_disp_idx].func_obj) {
func_disp_t *func_obj;
func_obj = create_func_disp(This, func);
if(!func_obj)
entry = dynamic_data->func_disps + func->func_disp_idx;
if(!entry->func_obj) {
entry->func_obj = create_func_disp(This, func);
if(!entry->func_obj)
return E_OUTOFMEMORY;
dynamic_data->func_disps[func->func_disp_idx].func_obj = func_obj;
IDispatchEx_AddRef(&func_obj->dispex.IDispatchEx_iface);
dynamic_data->func_disps[func->func_disp_idx].val = (IDispatch*)&func_obj->dispex.IDispatchEx_iface;
IDispatchEx_AddRef(&entry->func_obj->dispex.IDispatchEx_iface);
V_VT(&entry->val) = VT_DISPATCH;
V_DISPATCH(&entry->val) = (IDispatch*)&entry->func_obj->dispex.IDispatchEx_iface;
}
*ret = dynamic_data->func_disps+func->func_disp_idx;
*ret = entry;
return S_OK;
}
@ -1116,13 +1115,18 @@ static HRESULT function_invoke(DispatchEx *This, func_info_t *func, WORD flags,
&& This->dynamic_data->func_disps[func->func_disp_idx].func_obj) {
func_obj_entry_t *entry = This->dynamic_data->func_disps + func->func_disp_idx;
if((IDispatch*)&entry->func_obj->dispex.IDispatchEx_iface != entry->val) {
if(!entry->val) {
if(V_VT(&entry->val) != VT_DISPATCH) {
FIXME("calling %s not supported\n", debugstr_variant(&entry->val));
return E_NOTIMPL;
}
if((IDispatch*)&entry->func_obj->dispex.IDispatchEx_iface != V_DISPATCH(&entry->val)) {
if(!V_DISPATCH(&entry->val)) {
FIXME("Calling null\n");
return E_FAIL;
}
hres = invoke_disp_value(This, entry->val, 0, flags, dp, res, ei, NULL);
hres = invoke_disp_value(This, V_DISPATCH(&entry->val), 0, flags, dp, res, ei, NULL);
break;
}
}
@ -1151,16 +1155,11 @@ static HRESULT function_invoke(DispatchEx *This, func_info_t *func, WORD flags,
if(FAILED(hres))
return hres;
V_VT(res) = VT_DISPATCH;
V_DISPATCH(res) = entry->val;
if(V_DISPATCH(res))
IDispatch_AddRef(V_DISPATCH(res));
hres = S_OK;
break;
V_VT(res) = VT_EMPTY;
return VariantCopy(res, &entry->val);
}
case DISPATCH_PROPERTYPUT: {
func_obj_entry_t *entry;
VARIANT *v;
if(dp->cArgs != 1 || (dp->cNamedArgs == 1 && *dp->rgdispidNamedArgs != DISPID_PROPERTYPUT)
|| dp->cNamedArgs > 1) {
@ -1168,22 +1167,17 @@ static HRESULT function_invoke(DispatchEx *This, func_info_t *func, WORD flags,
return E_INVALIDARG;
}
v = dp->rgvarg;
/* FIXME: not exactly right */
if(V_VT(v) != VT_DISPATCH)
return E_NOTIMPL;
/*
* NOTE: Although we have IDispatchEx tests showing, that it's not allowed to set
* function property using InvokeEx, it's possible to do that from jscript.
* Native probably uses some undocumented interface in this case, but it should
* be fine for us to allow IDispatchEx handle that.
*/
hres = get_func_obj_entry(This, func, &entry);
if(FAILED(hres))
return hres;
if(entry->val)
IDispatch_Release(entry->val);
entry->val = V_DISPATCH(v);
if(entry->val)
IDispatch_AddRef(entry->val);
hres = S_OK;
break;
return VariantCopy(&entry->val, dp->rgvarg);
}
default:
FIXME("Unimplemented flags %x\n", flags);
@ -1215,7 +1209,6 @@ static HRESULT invoke_builtin_prop(DispatchEx *This, DISPID id, LCID lcid, WORD
switch(flags) {
case DISPATCH_PROPERTYPUT:
case DISPATCH_PROPERTYPUT | DISPATCH_PROPERTYPUTREF:
if(res)
V_VT(res) = VT_EMPTY;
hres = builtin_propput(This, func, dp, caller);
@ -1253,41 +1246,75 @@ static HRESULT invoke_builtin_prop(DispatchEx *This, DISPID id, LCID lcid, WORD
return hres;
}
HRESULT remove_prop(DispatchEx *This, BSTR name, VARIANT_BOOL *success)
HRESULT remove_attribute(DispatchEx *This, DISPID id, VARIANT_BOOL *success)
{
dynamic_prop_t *prop;
DISPID id;
HRESULT hres;
switch(get_dispid_type(id)) {
case DISPEXPROP_CUSTOM:
FIXME("DISPEXPROP_CUSTOM not supported\n");
return E_NOTIMPL;
hres = get_builtin_id(This, name, 0, &id);
if(hres == S_OK) {
DISPID named_id = DISPID_PROPERTYPUT;
case DISPEXPROP_DYNAMIC: {
DWORD idx = id - DISPID_DYNPROP_0;
dynamic_prop_t *prop;
prop = This->dynamic_data->props+idx;
VariantClear(&prop->var);
prop->flags |= DYNPROP_DELETED;
*success = VARIANT_TRUE;
return S_OK;
}
case DISPEXPROP_BUILTIN: {
VARIANT var;
DISPPARAMS dp = {&var,&named_id,1,1};
EXCEPINFO ei;
DISPPARAMS dp = {&var,NULL,1,0};
dispex_data_t *data;
func_info_t *func;
HRESULT hres;
data = get_dispex_data(This);
if(!data)
return E_FAIL;
hres = get_builtin_func(data, id, &func);
if(FAILED(hres))
return hres;
/* For builtin functions, we set their value to the original function. */
if(func->func_disp_idx != -1) {
func_obj_entry_t *entry;
if(!This->dynamic_data || !This->dynamic_data->func_disps
|| !This->dynamic_data->func_disps[func->func_disp_idx].func_obj) {
*success = VARIANT_FALSE;
return S_OK;
}
entry = This->dynamic_data->func_disps + func->func_disp_idx;
if(V_VT(&entry->val) == VT_DISPATCH
&& V_DISPATCH(&entry->val) == (IDispatch*)&entry->func_obj->dispex.IDispatchEx_iface) {
*success = VARIANT_FALSE;
return S_OK;
}
VariantClear(&entry->val);
V_VT(&entry->val) = VT_DISPATCH;
V_DISPATCH(&entry->val) = (IDispatch*)&entry->func_obj->dispex.IDispatchEx_iface;
IDispatch_AddRef(V_DISPATCH(&entry->val));
*success = VARIANT_TRUE;
return S_OK;
}
V_VT(&var) = VT_EMPTY;
memset(&ei, 0, sizeof(ei));
hres = invoke_builtin_prop(This, id, 0, DISPATCH_PROPERTYPUT, &dp, NULL, &ei, NULL);
hres = builtin_propput(This, func, &dp, NULL);
if(FAILED(hres))
return hres;
*success = VARIANT_TRUE;
return S_OK;
}
hres = get_dynamic_prop(This, name, 0, &prop);
if(FAILED(hres)) {
if(hres != DISP_E_UNKNOWNNAME)
return hres;
*success = VARIANT_FALSE;
return S_OK;
default:
assert(0);
return E_FAIL;
}
VariantClear(&prop->var);
prop->flags |= DYNPROP_DELETED;
*success = VARIANT_TRUE;
return S_OK;
}
static inline DispatchEx *impl_from_IDispatchEx(IDispatchEx *iface)
@ -1406,6 +1433,9 @@ static HRESULT WINAPI DispatchEx_InvokeEx(IDispatchEx *iface, DISPID id, LCID lc
TRACE("(%p)->(%x %x %x %p %p %p %p)\n", This, id, lcid, wFlags, pdp, pvarRes, pei, pspCaller);
if(wFlags == (DISPATCH_PROPERTYPUT|DISPATCH_PROPERTYPUTREF))
wFlags = DISPATCH_PROPERTYPUT;
switch(get_dispid_type(id)) {
case DISPEXPROP_CUSTOM:
if(!This->data->vtbl || !This->data->vtbl->invoke)
@ -1438,7 +1468,6 @@ static HRESULT WINAPI DispatchEx_InvokeEx(IDispatchEx *iface, DISPID id, LCID lc
return DISP_E_UNKNOWNNAME;
V_VT(pvarRes) = VT_EMPTY;
return variant_copy(pvarRes, &prop->var);
case DISPATCH_PROPERTYPUT|DISPATCH_PROPERTYPUTREF:
case DISPATCH_PROPERTYPUT:
if(pdp->cArgs != 1 || (pdp->cNamedArgs == 1 && *pdp->rgdispidNamedArgs != DISPID_PROPERTYPUT)
|| pdp->cNamedArgs > 1) {
@ -1626,26 +1655,16 @@ static IDispatchExVtbl DispatchExVtbl = {
BOOL dispex_query_interface(DispatchEx *This, REFIID riid, void **ppv)
{
static const IID IID_UndocumentedScriptIface =
{0x719c3050,0xf9d3,0x11cf,{0xa4,0x93,0x00,0x40,0x05,0x23,0xa8,0xa0}};
static const IID IID_IDispatchJS =
{0x719c3050,0xf9d3,0x11cf,{0xa4,0x93,0x00,0x40,0x05,0x23,0xa8,0xa6}};
if(IsEqualGUID(&IID_IDispatch, riid)) {
TRACE("(%p)->(IID_IDispatch %p)\n", This, ppv);
if(IsEqualGUID(&IID_IDispatch, riid))
*ppv = &This->IDispatchEx_iface;
}else if(IsEqualGUID(&IID_IDispatchEx, riid)) {
TRACE("(%p)->(IID_IDispatchEx %p)\n", This, ppv);
else if(IsEqualGUID(&IID_IDispatchEx, riid))
*ppv = &This->IDispatchEx_iface;
}else if(IsEqualGUID(&IID_IDispatchJS, riid)) {
TRACE("(%p)->(IID_IDispatchJS %p) returning NULL\n", This, ppv);
else if(IsEqualGUID(&IID_IDispatchJS, riid))
*ppv = NULL;
}else if(IsEqualGUID(&IID_UndocumentedScriptIface, riid)) {
TRACE("(%p)->(IID_UndocumentedScriptIface %p) returning NULL\n", This, ppv);
else if(IsEqualGUID(&IID_UndocumentedScriptIface, riid))
*ppv = NULL;
}else {
else
return FALSE;
}
if(*ppv)
IUnknown_AddRef((IUnknown*)*ppv);
@ -1706,8 +1725,7 @@ void release_dispex(DispatchEx *This)
iter->func_obj->obj = NULL;
IDispatchEx_Release(&iter->func_obj->dispex.IDispatchEx_iface);
}
if(iter->val)
IDispatch_Release(iter->val);
VariantClear(&iter->val);
}
heap_free(This->dynamic_data->func_disps);

9
reactos/dll/win32/mshtml/editor.c
View file

@ -1153,13 +1153,14 @@ static HRESULT exec_hyperlink(HTMLDocument *This, DWORD cmdexecopt, VARIANT *in,
/* create an element with text of URL */
if (insert_link_at_caret) {
nsIDOMNode *text_node, *unused_node;
nsIDOMNode *unused_node;
nsIDOMText *text_node;
nsIDOMHTMLDocument_CreateTextNode(This->doc_node->nsdoc, &ns_url, (nsIDOMText **)&text_node);
nsIDOMHTMLDocument_CreateTextNode(This->doc_node->nsdoc, &ns_url, &text_node);
/* wrap the <a> tags around the text element */
nsIDOMHTMLElement_AppendChild(anchor_elem, text_node, &unused_node);
nsIDOMNode_Release(text_node);
nsIDOMHTMLElement_AppendChild(anchor_elem, (nsIDOMNode*)text_node, &unused_node);
nsIDOMText_Release(text_node);
nsIDOMNode_Release(unused_node);
}

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

@ -25,6 +25,9 @@ DEFINE_OLEGUID(CGID_DocHostCmdPriv, 0x000214D4L, 0, 0);
DEFINE_GUID(CLSID_JScript, 0xf414c260,0x6ac0,0x11cf, 0xb6,0xd1,0x00,0xaa,0x00,0xbb,0xbb,0x58);
DEFINE_GUID(CLSID_VBScript, 0xb54f3741,0x5b07,0x11cf, 0xa4,0xb0,0x00,0xaa,0x00,0x4a,0x55,0xe8);
DEFINE_GUID(IID_UndocumentedScriptIface,0x719c3050,0xf9d3,0x11cf,0xa4,0x93,0x00,0x40,0x05,0x23,0xa8,0xa0);
DEFINE_GUID(IID_IDispatchJS,0x719c3050,0xf9d3,0x11cf,0xa4,0x93,0x00,0x40,0x05,0x23,0xa8,0xa6);
/* htmlnode.c */
DEFINE_GUID(IID_nsXPCOMCycleCollectionParticipant, 0x9674489b,0x1f6f,0x4550,0xa7,0x30, 0xcc,0xae,0xdd,0x10,0x4c,0xf9);

2
reactos/dll/win32/mshtml/hlink.c
View file

@ -71,7 +71,7 @@ static HRESULT WINAPI HlinkTarget_Navigate(IHlinkTarget *iface, DWORD grfHLNF, L
FIXME("JumpLocation not supported\n");
if(!This->doc_obj->client)
return navigate_new_window(This->window, This->window->uri, NULL, NULL);
return navigate_new_window(This->window, This->window->uri, NULL, NULL, NULL);
return IOleObject_DoVerb(&This->IOleObject_iface, OLEIVERB_SHOW, NULL, NULL, -1, NULL, NULL);
}

66
reactos/dll/win32/mshtml/htmlanchor.c
View file

@ -48,7 +48,7 @@ static HRESULT navigate_anchor_window(HTMLAnchorElement *This, const WCHAR *targ
if(FAILED(hres))
return hres;
hres = navigate_new_window(This->element.node.doc->basedoc.window, uri, target, NULL);
hres = navigate_new_window(This->element.node.doc->basedoc.window, uri, target, NULL, NULL);
IUri_Release(uri);
return hres;
}
@ -462,15 +462,31 @@ static HRESULT WINAPI HTMLAnchorElement_get_protocol(IHTMLAnchorElement *iface,
static HRESULT WINAPI HTMLAnchorElement_put_search(IHTMLAnchorElement *iface, BSTR v)
{
HTMLAnchorElement *This = impl_from_IHTMLAnchorElement(iface);
FIXME("(%p)->(%s)\n", This, debugstr_w(v));
return E_NOTIMPL;
nsAString nsstr;
nsresult nsres;
TRACE("(%p)->(%s)\n", This, debugstr_w(v));
nsAString_InitDepend(&nsstr, v);
nsres = nsIDOMHTMLAnchorElement_SetSearch(This->nsanchor, &nsstr);
nsAString_Finish(&nsstr);
if(NS_FAILED(nsres))
return E_FAIL;
return S_OK;
}
static HRESULT WINAPI HTMLAnchorElement_get_search(IHTMLAnchorElement *iface, BSTR *p)
{
HTMLAnchorElement *This = impl_from_IHTMLAnchorElement(iface);
FIXME("(%p)->(%p)\n", This, p);
return E_NOTIMPL;
nsAString search_str;
nsresult nsres;
TRACE("(%p)->(%p)\n", This, p);
nsAString_Init(&search_str, NULL);
nsres = nsIDOMHTMLAnchorElement_GetSearch(This->nsanchor, &search_str);
return return_nsstr(nsres, &search_str, p);
}
static HRESULT WINAPI HTMLAnchorElement_put_hash(IHTMLAnchorElement *iface, BSTR v)
@ -691,7 +707,7 @@ static HRESULT HTMLAnchorElement_handle_event(HTMLDOMNode *iface, eventid_t eid,
if(eid == EVENTID_CLICK) {
nsIDOMMouseEvent *mouse_event;
UINT16 button;
INT16 button;
nsresult nsres;
TRACE("CLICK\n");
@ -720,13 +736,44 @@ static HRESULT HTMLAnchorElement_handle_event(HTMLDOMNode *iface, eventid_t eid,
return HTMLElement_handle_event(&This->element.node, eid, event, prevent_default);
}
static void HTMLAnchorElement_traverse(HTMLDOMNode *iface, nsCycleCollectionTraversalCallback *cb)
{
HTMLAnchorElement *This = impl_from_HTMLDOMNode(iface);
if(This->nsanchor)
note_cc_edge((nsISupports*)This->nsanchor, "This->nsanchor", cb);
}
static void HTMLAnchorElement_unlink(HTMLDOMNode *iface)
{
HTMLAnchorElement *This = impl_from_HTMLDOMNode(iface);
if(This->nsanchor) {
nsIDOMHTMLAnchorElement *nsanchor = This->nsanchor;
This->nsanchor = NULL;
nsIDOMHTMLAnchorElement_Release(nsanchor);
}
}
static const NodeImplVtbl HTMLAnchorElementImplVtbl = {
HTMLAnchorElement_QI,
HTMLElement_destructor,
HTMLElement_cpc,
HTMLElement_clone,
HTMLAnchorElement_handle_event,
HTMLElement_get_attr_col
HTMLElement_get_attr_col,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
HTMLAnchorElement_traverse,
HTMLAnchorElement_unlink
};
static const tid_t HTMLAnchorElement_iface_tids[] = {
@ -758,10 +805,7 @@ HRESULT HTMLAnchorElement_Create(HTMLDocumentNode *doc, nsIDOMHTMLElement *nsele
HTMLElement_Init(&ret->element, doc, nselem, &HTMLAnchorElement_dispex);
nsres = nsIDOMHTMLElement_QueryInterface(nselem, &IID_nsIDOMHTMLAnchorElement, (void**)&ret->nsanchor);
/* Shere the reference with nsnode */
assert(nsres == NS_OK && (nsIDOMNode*)ret->nsanchor == ret->element.node.nsnode);
nsIDOMNode_Release(ret->element.node.nsnode);
assert(nsres == NS_OK);
*elem = &ret->element;
return S_OK;

36
reactos/dll/win32/mshtml/htmlbody.c
View file

@ -789,13 +789,23 @@ static HRESULT HTMLBodyElement_QI(HTMLDOMNode *iface, REFIID riid, void **ppv)
return HTMLElement_QI(&This->textcont.element.node, riid, ppv);
}
static void HTMLBodyElement_destructor(HTMLDOMNode *iface)
static void HTMLBodyElement_traverse(HTMLDOMNode *iface, nsCycleCollectionTraversalCallback *cb)
{
HTMLBodyElement *This = impl_from_HTMLDOMNode(iface);
nsIDOMHTMLBodyElement_Release(This->nsbody);
if(This->nsbody)
note_cc_edge((nsISupports*)This->nsbody, "This->nsbody", cb);
}
HTMLElement_destructor(&This->textcont.element.node);
static void HTMLBodyElement_unlink(HTMLDOMNode *iface)
{
HTMLBodyElement *This = impl_from_HTMLDOMNode(iface);
if(This->nsbody) {
nsIDOMHTMLBodyElement *nsbody = This->nsbody;
This->nsbody = NULL;
nsIDOMHTMLBodyElement_Release(nsbody);
}
}
static event_target_t **HTMLBodyElement_get_event_target(HTMLDOMNode *iface)
@ -807,6 +817,11 @@ static event_target_t **HTMLBodyElement_get_event_target(HTMLDOMNode *iface)
: &This->textcont.element.node.event_target;
}
static BOOL HTMLBodyElement_is_text_edit(HTMLDOMNode *iface)
{
return TRUE;
}
static const cpc_entry_t HTMLBodyElement_cpc[] = {
{&DIID_HTMLTextContainerEvents},
{&IID_IPropertyNotifySink},
@ -816,12 +831,23 @@ static const cpc_entry_t HTMLBodyElement_cpc[] = {
static const NodeImplVtbl HTMLBodyElementImplVtbl = {
HTMLBodyElement_QI,
HTMLBodyElement_destructor,
HTMLElement_destructor,
HTMLBodyElement_cpc,
HTMLElement_clone,
HTMLElement_handle_event,
HTMLElement_get_attr_col,
HTMLBodyElement_get_event_target
HTMLBodyElement_get_event_target,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
HTMLBodyElement_traverse,
HTMLBodyElement_unlink,
HTMLBodyElement_is_text_edit
};
static const tid_t HTMLBodyElement_iface_tids[] = {

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

@ -18,6 +18,8 @@
#include "mshtml_private.h"
static HRESULT create_document_fragment(nsIDOMNode *nsnode, HTMLDocumentNode *doc_node, HTMLDocumentNode **ret);
HRESULT get_doc_elem_by_id(HTMLDocumentNode *doc, const WCHAR *id, HTMLElement **ret)
{
nsIDOMNodeList *nsnode_list;
@ -91,6 +93,38 @@ HRESULT get_doc_elem_by_id(HTMLDocumentNode *doc, const WCHAR *id, HTMLElement *
return hres;
}
UINT get_document_charset(HTMLDocumentNode *doc)
{
nsAString charset_str;
UINT ret = 0;
nsresult nsres;
if(doc->charset)
return doc->charset;
nsAString_Init(&charset_str, NULL);
nsres = nsIDOMHTMLDocument_GetCharacterSet(doc->nsdoc, &charset_str);
if(NS_SUCCEEDED(nsres)) {
const PRUnichar *charset;
nsAString_GetData(&charset_str, &charset);
if(*charset) {
BSTR str = SysAllocString(charset);
ret = cp_from_charset_string(str);
SysFreeString(str);
}
}else {
ERR("GetCharset failed: %08x\n", nsres);
}
nsAString_Finish(&charset_str);
if(!ret)
return CP_UTF8;
return doc->charset = ret;
}
static inline HTMLDocument *impl_from_IHTMLDocument2(IHTMLDocument2 *iface)
{
return CONTAINING_RECORD(iface, HTMLDocument, IHTMLDocument2_iface);
@ -258,6 +292,11 @@ static HRESULT WINAPI HTMLDocument_get_activeElement(IHTMLDocument2 *iface, IHTM
return E_FAIL;
}
if(!nselem) {
*p = NULL;
return S_OK;
}
hres = get_elem(This->doc_node, nselem, &elem);
nsIDOMElement_Release(nselem);
if(FAILED(hres))
@ -569,27 +608,13 @@ static HRESULT WINAPI HTMLDocument_get_readyState(IHTMLDocument2 *iface, BSTR *p
{
HTMLDocument *This = impl_from_IHTMLDocument2(iface);
static const WCHAR wszUninitialized[] = {'u','n','i','n','i','t','i','a','l','i','z','e','d',0};
static const WCHAR wszLoading[] = {'l','o','a','d','i','n','g',0};
static const WCHAR wszLoaded[] = {'l','o','a','d','e','d',0};
static const WCHAR wszInteractive[] = {'i','n','t','e','r','a','c','t','i','v','e',0};
static const WCHAR wszComplete[] = {'c','o','m','p','l','e','t','e',0};
static const LPCWSTR readystate_str[] = {
wszUninitialized,
wszLoading,
wszLoaded,
wszInteractive,
wszComplete
};
TRACE("(%p)->(%p)\n", iface, p);
if(!p)
return E_POINTER;
*p = SysAllocString(readystate_str[This->window->readystate]);
return S_OK;
return get_readystate_string(This->window->readystate, p);
}
static HRESULT WINAPI HTMLDocument_get_frames(IHTMLDocument2 *iface, IHTMLFramesCollection2 **p)
@ -1086,6 +1111,58 @@ static HRESULT WINAPI HTMLDocument_clear(IHTMLDocument2 *iface)
return S_OK;
}
static const WCHAR copyW[] =
{'c','o','p','y',0};
static const WCHAR cutW[] =
{'c','u','t',0};
static const WCHAR fontnameW[] =
{'f','o','n','t','n','a','m','e',0};
static const WCHAR fontsizeW[] =
{'f','o','n','t','s','i','z','e',0};
static const WCHAR indentW[] =
{'i','n','d','e','n','t',0};
static const WCHAR insertorderedlistW[] =
{'i','n','s','e','r','t','o','r','d','e','r','e','d','l','i','s','t',0};
static const WCHAR insertunorderedlistW[] =
{'i','n','s','e','r','t','u','n','o','r','d','e','r','e','d','l','i','s','t',0};
static const WCHAR outdentW[] =
{'o','u','t','d','e','n','t',0};
static const WCHAR pasteW[] =
{'p','a','s','t','e',0};
static const WCHAR respectvisibilityindesignW[] =
{'r','e','s','p','e','c','t','v','i','s','i','b','i','l','i','t','y','i','n','d','e','s','i','g','n',0};
static const struct {
const WCHAR *name;
OLECMDID id;
}command_names[] = {
{copyW, IDM_COPY},
{cutW, IDM_CUT},
{fontnameW, IDM_FONTNAME},
{fontsizeW, IDM_FONTSIZE},
{indentW, IDM_INDENT},
{insertorderedlistW, IDM_ORDERLIST},
{insertunorderedlistW, IDM_UNORDERLIST},
{outdentW, IDM_OUTDENT},
{pasteW, IDM_PASTE},
{respectvisibilityindesignW, IDM_RESPECTVISIBILITY_INDESIGN}
};
static BOOL cmdid_from_string(const WCHAR *str, OLECMDID *cmdid)
{
int i;
for(i = 0; i < sizeof(command_names)/sizeof(*command_names); i++) {
if(!strcmpiW(command_names[i].name, str)) {
*cmdid = command_names[i].id;
return TRUE;
}
}
FIXME("Unknown command %s\n", debugstr_w(str));
return FALSE;
}
static HRESULT WINAPI HTMLDocument_queryCommandSupported(IHTMLDocument2 *iface, BSTR cmdID,
VARIANT_BOOL *pfRet)
{
@ -1138,8 +1215,28 @@ static HRESULT WINAPI HTMLDocument_execCommand(IHTMLDocument2 *iface, BSTR cmdID
VARIANT_BOOL showUI, VARIANT value, VARIANT_BOOL *pfRet)
{
HTMLDocument *This = impl_from_IHTMLDocument2(iface);
FIXME("(%p)->(%s %x %s %p)\n", This, debugstr_w(cmdID), showUI, debugstr_variant(&value), pfRet);
return E_NOTIMPL;
OLECMDID cmdid;
VARIANT ret;
HRESULT hres;
TRACE("(%p)->(%s %x %s %p)\n", This, debugstr_w(cmdID), showUI, debugstr_variant(&value), pfRet);
if(!cmdid_from_string(cmdID, &cmdid))
return OLECMDERR_E_NOTSUPPORTED;
V_VT(&ret) = VT_EMPTY;
hres = IOleCommandTarget_Exec(&This->IOleCommandTarget_iface, &CGID_MSHTML, cmdid,
showUI ? 0 : OLECMDEXECOPT_DONTPROMPTUSER, &value, &ret);
if(FAILED(hres))
return hres;
if(V_VT(&ret) != VT_EMPTY) {
FIXME("Handle ret %s\n", debugstr_variant(&ret));
VariantClear(&ret);
}
*pfRet = VARIANT_TRUE;
return S_OK;
}
static HRESULT WINAPI HTMLDocument_execCommandShowHelp(IHTMLDocument2 *iface, BSTR cmdID,
@ -1202,15 +1299,19 @@ static HRESULT WINAPI HTMLDocument_get_onclick(IHTMLDocument2 *iface, VARIANT *p
static HRESULT WINAPI HTMLDocument_put_ondblclick(IHTMLDocument2 *iface, VARIANT v)
{
HTMLDocument *This = impl_from_IHTMLDocument2(iface);
FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
return E_NOTIMPL;
TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
return set_doc_event(This, EVENTID_DBLCLICK, &v);
}
static HRESULT WINAPI HTMLDocument_get_ondblclick(IHTMLDocument2 *iface, VARIANT *p)
{
HTMLDocument *This = impl_from_IHTMLDocument2(iface);
FIXME("(%p)->(%p)\n", This, p);
return E_NOTIMPL;
TRACE("(%p)->(%p)\n", This, p);
return get_doc_event(This, EVENTID_DBLCLICK, p);
}
static HRESULT WINAPI HTMLDocument_put_onkeyup(IHTMLDocument2 *iface, VARIANT v)
@ -1590,7 +1691,7 @@ static HRESULT WINAPI HTMLDocument_createStyleSheet(IHTMLDocument2 *iface, BSTR
if(lIndex != -1)
FIXME("Unsupported lIndex %d\n", lIndex);
if(bstrHref) {
if(bstrHref && *bstrHref) {
FIXME("semi-stub for href %s\n", debugstr_w(bstrHref));
*ppnewStyleSheet = HTMLStyleSheet_Create(NULL);
return S_OK;
@ -1602,10 +1703,14 @@ static HRESULT WINAPI HTMLDocument_createStyleSheet(IHTMLDocument2 *iface, BSTR
nsres = nsIDOMHTMLDocument_GetHead(This->doc_node->nsdoc, &head_elem);
if(NS_SUCCEEDED(nsres)) {
nsIDOMNode *tmp_node;
nsIDOMNode *head_node, *tmp_node;
nsres = nsIDOMHTMLHeadElement_AppendChild(head_elem, (nsIDOMNode*)elem->nselem, &tmp_node);
nsres = nsIDOMHTMLHeadElement_QueryInterface(head_elem, &IID_nsIDOMNode, (void**)&head_node);
nsIDOMHTMLHeadElement_Release(head_elem);
assert(nsres == NS_OK);
nsres = nsIDOMNode_AppendChild(head_node, elem->node.nsnode, &tmp_node);
nsIDOMNode_Release(head_node);
if(NS_SUCCEEDED(nsres) && tmp_node)
nsIDOMNode_Release(tmp_node);
}
@ -1807,8 +1912,11 @@ static HRESULT WINAPI HTMLDocument3_releaseCapture(IHTMLDocument3 *iface)
static HRESULT WINAPI HTMLDocument3_recalc(IHTMLDocument3 *iface, VARIANT_BOOL fForce)
{
HTMLDocument *This = impl_from_IHTMLDocument3(iface);
FIXME("(%p)->(%x)\n", This, fForce);
return E_NOTIMPL;
WARN("(%p)->(%x)\n", This, fForce);
/* Doing nothing here should be fine for us. */
return S_OK;
}
static HRESULT WINAPI HTMLDocument3_createTextNode(IHTMLDocument3 *iface, BSTR text,
@ -2195,7 +2303,7 @@ static HRESULT WINAPI HTMLDocument3_getElementsByName(IHTMLDocument3 *iface, BST
* types and search should be case insensitive. Those are currently not supported properly.
*/
nsAString_InitDepend(&selector_str, selector);
nsres = nsIDOMNodeSelector_QuerySelectorAll(This->doc_node->nsnode_selector, &selector_str, &node_list);
nsres = nsIDOMHTMLDocument_QuerySelectorAll(This->doc_node->nsdoc, &selector_str, &node_list);
nsAString_Finish(&selector_str);
heap_free(selector);
if(NS_FAILED(nsres)) {
@ -4324,11 +4432,6 @@ static void HTMLDocumentNode_destructor(HTMLDOMNode *iface)
while(!list_empty(&This->plugin_hosts))
detach_plugin_host(LIST_ENTRY(list_head(&This->plugin_hosts), PluginHost, entry));
if(This->nsnode_selector) {
nsIDOMNodeSelector_Release(This->nsnode_selector);
This->nsnode_selector = NULL;
}
if(!This->nsdoc && This->window) {
/* document fragments own reference to inner window */
IHTMLWindow2_Release(&This->window->base.IHTMLWindow2_iface);
@ -4350,8 +4453,6 @@ static void HTMLDocumentNode_traverse(HTMLDOMNode *iface, nsCycleCollectionTrave
{
HTMLDocumentNode *This = impl_from_HTMLDOMNode(iface);
if(This->nsnode_selector)
note_cc_edge((nsISupports*)This->nsnode_selector, "This->nsnode_selector", cb);
if(This->nsdoc)
note_cc_edge((nsISupports*)This->nsdoc, "This->nsdoc", cb);
}
@ -4360,11 +4461,6 @@ static void HTMLDocumentNode_unlink(HTMLDOMNode *iface)
{
HTMLDocumentNode *This = impl_from_HTMLDOMNode(iface);
if(This->nsnode_selector) {
nsIDOMNodeSelector_Release(This->nsnode_selector);
This->nsnode_selector = NULL;
}
if(This->nsdoc) {
nsIDOMHTMLDocument *nsdoc = This->nsdoc;
@ -4518,7 +4614,6 @@ static HTMLDocumentNode *alloc_doc_node(HTMLDocumentObj *doc_obj, HTMLInnerWindo
HRESULT create_doc_from_nsdoc(nsIDOMHTMLDocument *nsdoc, HTMLDocumentObj *doc_obj, HTMLInnerWindow *window, HTMLDocumentNode **ret)
{
HTMLDocumentNode *doc;
nsresult nsres;
doc = alloc_doc_node(doc_obj, window);
if(!doc)
@ -4532,9 +4627,6 @@ HRESULT create_doc_from_nsdoc(nsIDOMHTMLDocument *nsdoc, HTMLDocumentObj *doc_ob
nsIDOMHTMLDocument_AddRef(nsdoc);
doc->nsdoc = nsdoc;
nsres = nsIDOMHTMLDocument_QueryInterface(nsdoc, &IID_nsIDOMNodeSelector, (void**)&doc->nsnode_selector);
assert(nsres == NS_OK);
init_document_mutation(doc);
doc_init_events(doc);
@ -4545,7 +4637,7 @@ HRESULT create_doc_from_nsdoc(nsIDOMHTMLDocument *nsdoc, HTMLDocumentObj *doc_ob
return S_OK;
}
HRESULT create_document_fragment(nsIDOMNode *nsnode, HTMLDocumentNode *doc_node, HTMLDocumentNode **ret)
static HRESULT create_document_fragment(nsIDOMNode *nsnode, HTMLDocumentNode *doc_node, HTMLDocumentNode **ret)
{
HTMLDocumentNode *doc_frag;

2134
reactos/dll/win32/mshtml/htmlelem.c
View file

File diff suppressed because it is too large Load diff

1370
reactos/dll/win32/mshtml/htmlelem2.c
View file

File diff suppressed because it is too large Load diff

669
reactos/dll/win32/mshtml/htmlelem3.c
View file

@ -1,669 +0,0 @@
/*
* Copyright 2008 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
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*/
#include "mshtml_private.h"
static inline HTMLElement *impl_from_IHTMLElement3(IHTMLElement3 *iface)
{
return CONTAINING_RECORD(iface, HTMLElement, IHTMLElement3_iface);
}
static HRESULT WINAPI HTMLElement3_QueryInterface(IHTMLElement3 *iface,
REFIID riid, void **ppv)
{
HTMLElement *This = impl_from_IHTMLElement3(iface);
return IHTMLElement_QueryInterface(&This->IHTMLElement_iface, riid, ppv);
}
static ULONG WINAPI HTMLElement3_AddRef(IHTMLElement3 *iface)
{
HTMLElement *This = impl_from_IHTMLElement3(iface);
return IHTMLElement_AddRef(&This->IHTMLElement_iface);
}
static ULONG WINAPI HTMLElement3_Release(IHTMLElement3 *iface)
{
HTMLElement *This = impl_from_IHTMLElement3(iface);
return IHTMLElement_Release(&This->IHTMLElement_iface);
}
static HRESULT WINAPI HTMLElement3_GetTypeInfoCount(IHTMLElement3 *iface, UINT *pctinfo)
{
HTMLElement *This = impl_from_IHTMLElement3(iface);
return IDispatchEx_GetTypeInfoCount(&This->node.dispex.IDispatchEx_iface, pctinfo);
}
static HRESULT WINAPI HTMLElement3_GetTypeInfo(IHTMLElement3 *iface, UINT iTInfo,
LCID lcid, ITypeInfo **ppTInfo)
{
HTMLElement *This = impl_from_IHTMLElement3(iface);
return IDispatchEx_GetTypeInfo(&This->node.dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
}
static HRESULT WINAPI HTMLElement3_GetIDsOfNames(IHTMLElement3 *iface, REFIID riid,
LPOLESTR *rgszNames, UINT cNames,
LCID lcid, DISPID *rgDispId)
{
HTMLElement *This = impl_from_IHTMLElement3(iface);
return IDispatchEx_GetIDsOfNames(&This->node.dispex.IDispatchEx_iface, riid, rgszNames, cNames,
lcid, rgDispId);
}
static HRESULT WINAPI HTMLElement3_Invoke(IHTMLElement3 *iface, DISPID dispIdMember,
REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
{
HTMLElement *This = impl_from_IHTMLElement3(iface);
return IDispatchEx_Invoke(&This->node.dispex.IDispatchEx_iface, dispIdMember, riid, lcid,
wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
}
static HRESULT WINAPI HTMLElement3_mergeAttributes(IHTMLElement3 *iface, IHTMLElement *mergeThis, VARIANT *pvarFlags)
{
HTMLElement *This = impl_from_IHTMLElement3(iface);
FIXME("(%p)->(%p %p)\n", This, mergeThis, pvarFlags);
return E_NOTIMPL;
}
static HRESULT WINAPI HTMLElement3_get_isMultiLine(IHTMLElement3 *iface, VARIANT_BOOL *p)
{
HTMLElement *This = impl_from_IHTMLElement3(iface);
FIXME("(%p)->(%p)\n", This, p);
return E_NOTIMPL;
}
static HRESULT WINAPI HTMLElement3_get_canHaveHTML(IHTMLElement3 *iface, VARIANT_BOOL *p)
{
HTMLElement *This = impl_from_IHTMLElement3(iface);
FIXME("(%p)->(%p)\n", This, p);
return E_NOTIMPL;
}
static HRESULT WINAPI HTMLElement3_put_onlayoutcomplete(IHTMLElement3 *iface, VARIANT v)
{
HTMLElement *This = impl_from_IHTMLElement3(iface);
FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
return E_NOTIMPL;
}
static HRESULT WINAPI HTMLElement3_get_onlayoutcomplete(IHTMLElement3 *iface, VARIANT *p)
{
HTMLElement *This = impl_from_IHTMLElement3(iface);
FIXME("(%p)->(%p)\n", This, p);
return E_NOTIMPL;
}
static HRESULT WINAPI HTMLElement3_put_onpage(IHTMLElement3 *iface, VARIANT v)
{
HTMLElement *This = impl_from_IHTMLElement3(iface);
FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
return E_NOTIMPL;
}
static HRESULT WINAPI HTMLElement3_get_onpage(IHTMLElement3 *iface, VARIANT *p)
{
HTMLElement *This = impl_from_IHTMLElement3(iface);
FIXME("(%p)->(%p)\n", This, p);
return E_NOTIMPL;
}
static HRESULT WINAPI HTMLElement3_put_inflateBlock(IHTMLElement3 *iface, VARIANT_BOOL v)
{
HTMLElement *This = impl_from_IHTMLElement3(iface);
FIXME("(%p)->(%x)\n", This, v);
return E_NOTIMPL;
}
static HRESULT WINAPI HTMLElement3_get_inflateBlock(IHTMLElement3 *iface, VARIANT_BOOL *p)
{
HTMLElement *This = impl_from_IHTMLElement3(iface);
FIXME("(%p)->(%p)\n", This, p);
return E_NOTIMPL;
}
static HRESULT WINAPI HTMLElement3_put_onbeforedeactivate(IHTMLElement3 *iface, VARIANT v)
{
HTMLElement *This = impl_from_IHTMLElement3(iface);
FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
return E_NOTIMPL;
}
static HRESULT WINAPI HTMLElement3_get_onbeforedeactivate(IHTMLElement3 *iface, VARIANT *p)
{
HTMLElement *This = impl_from_IHTMLElement3(iface);
FIXME("(%p)->(%p)\n", This, p);
return E_NOTIMPL;
}
static HRESULT WINAPI HTMLElement3_setActive(IHTMLElement3 *iface)
{
HTMLElement *This = impl_from_IHTMLElement3(iface);
FIXME("(%p)\n", This);
return E_NOTIMPL;
}
static HRESULT WINAPI HTMLElement3_put_contentEditable(IHTMLElement3 *iface, BSTR v)
{
HTMLElement *This = impl_from_IHTMLElement3(iface);
nsresult nsres;
nsAString str;
TRACE("(%p)->(%s)\n", This, debugstr_w(v));
nsAString_InitDepend(&str, v);
nsres = nsIDOMHTMLElement_SetContentEditable(This->nselem, &str);
nsAString_Finish(&str);
if (NS_FAILED(nsres)){
ERR("SetContentEditable(%s) failed!\n", debugstr_w(v));
return E_FAIL;
}
return S_OK;
}
static HRESULT WINAPI HTMLElement3_get_contentEditable(IHTMLElement3 *iface, BSTR *p)
{
HTMLElement *This = impl_from_IHTMLElement3(iface);
nsresult nsres;
nsAString str;
TRACE("(%p)->(%p)\n", This, p);
nsAString_Init(&str, NULL);
nsres = nsIDOMHTMLElement_GetContentEditable(This->nselem, &str);
return return_nsstr(nsres, &str, p);
}
static HRESULT WINAPI HTMLElement3_get_isContentEditable(IHTMLElement3 *iface, VARIANT_BOOL *p)
{
HTMLElement *This = impl_from_IHTMLElement3(iface);
FIXME("(%p)->(%p)\n", This, p);
return E_NOTIMPL;
}
static HRESULT WINAPI HTMLElement3_put_hideFocus(IHTMLElement3 *iface, VARIANT_BOOL v)
{
HTMLElement *This = impl_from_IHTMLElement3(iface);
FIXME("(%p)->(%x)\n", This, v);
return E_NOTIMPL;
}
static HRESULT WINAPI HTMLElement3_get_hideFocus(IHTMLElement3 *iface, VARIANT_BOOL *p)
{
HTMLElement *This = impl_from_IHTMLElement3(iface);
FIXME("(%p)->(%p)\n", This, p);
return E_NOTIMPL;
}
static const WCHAR disabledW[] = {'d','i','s','a','b','l','e','d',0};
static HRESULT WINAPI HTMLElement3_put_disabled(IHTMLElement3 *iface, VARIANT_BOOL v)
{
HTMLElement *This = impl_from_IHTMLElement3(iface);
VARIANT *var;
HRESULT hres;
TRACE("(%p)->(%x)\n", This, v);
if(This->node.vtbl->put_disabled)
return This->node.vtbl->put_disabled(&This->node, v);
hres = dispex_get_dprop_ref(&This->node.dispex, disabledW, TRUE, &var);
if(FAILED(hres))
return hres;
VariantClear(var);
V_VT(var) = VT_BOOL;
V_BOOL(var) = v;
return S_OK;
}
static HRESULT WINAPI HTMLElement3_get_disabled(IHTMLElement3 *iface, VARIANT_BOOL *p)
{
HTMLElement *This = impl_from_IHTMLElement3(iface);
VARIANT *var;
HRESULT hres;
TRACE("(%p)->(%p)\n", This, p);
if(This->node.vtbl->get_disabled)
return This->node.vtbl->get_disabled(&This->node, p);
hres = dispex_get_dprop_ref(&This->node.dispex, disabledW, FALSE, &var);
if(hres == DISP_E_UNKNOWNNAME) {
*p = VARIANT_FALSE;
return S_OK;
}
if(FAILED(hres))
return hres;
if(V_VT(var) != VT_BOOL) {
FIXME("value is %s\n", debugstr_variant(var));
return E_NOTIMPL;
}
*p = V_BOOL(var);
return S_OK;
}
static HRESULT WINAPI HTMLElement3_get_isDisabled(IHTMLElement3 *iface, VARIANT_BOOL *p)
{
HTMLElement *This = impl_from_IHTMLElement3(iface);
FIXME("(%p)->(%p)\n", This, p);
return E_NOTIMPL;
}
static HRESULT WINAPI HTMLElement3_put_onmove(IHTMLElement3 *iface, VARIANT v)
{
HTMLElement *This = impl_from_IHTMLElement3(iface);
FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
return E_NOTIMPL;
}
static HRESULT WINAPI HTMLElement3_get_onmove(IHTMLElement3 *iface, VARIANT *p)
{
HTMLElement *This = impl_from_IHTMLElement3(iface);
FIXME("(%p)->(%p)\n", This, p);
return E_NOTIMPL;
}
static HRESULT WINAPI HTMLElement3_put_oncontrolselect(IHTMLElement3 *iface, VARIANT v)
{
HTMLElement *This = impl_from_IHTMLElement3(iface);
FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
return E_NOTIMPL;
}
static HRESULT WINAPI HTMLElement3_get_oncontrolselect(IHTMLElement3 *iface, VARIANT *p)
{
HTMLElement *This = impl_from_IHTMLElement3(iface);
FIXME("(%p)->(%p)\n", This, p);
return E_NOTIMPL;
}
static HRESULT WINAPI HTMLElement3_fireEvent(IHTMLElement3 *iface, BSTR bstrEventName,
VARIANT *pvarEventObject, VARIANT_BOOL *pfCancelled)
{
HTMLElement *This = impl_from_IHTMLElement3(iface);
TRACE("(%p)->(%s %s %p)\n", This, debugstr_w(bstrEventName), debugstr_variant(pvarEventObject),
pfCancelled);
return dispatch_event(&This->node, bstrEventName, pvarEventObject, pfCancelled);
}
static HRESULT WINAPI HTMLElement3_put_onresizestart(IHTMLElement3 *iface, VARIANT v)
{
HTMLElement *This = impl_from_IHTMLElement3(iface);
FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
return E_NOTIMPL;
}
static HRESULT WINAPI HTMLElement3_get_onresizestart(IHTMLElement3 *iface, VARIANT *p)
{
HTMLElement *This = impl_from_IHTMLElement3(iface);
FIXME("(%p)->(%p)\n", This, p);
return E_NOTIMPL;
}
static HRESULT WINAPI HTMLElement3_put_onresizeend(IHTMLElement3 *iface, VARIANT v)
{
HTMLElement *This = impl_from_IHTMLElement3(iface);
FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
return E_NOTIMPL;
}
static HRESULT WINAPI HTMLElement3_get_onresizeend(IHTMLElement3 *iface, VARIANT *p)
{
HTMLElement *This = impl_from_IHTMLElement3(iface);
FIXME("(%p)->(%p)\n", This, p);
return E_NOTIMPL;
}
static HRESULT WINAPI HTMLElement3_put_onmovestart(IHTMLElement3 *iface, VARIANT v)
{
HTMLElement *This = impl_from_IHTMLElement3(iface);
FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
return E_NOTIMPL;
}
static HRESULT WINAPI HTMLElement3_get_onmovestart(IHTMLElement3 *iface, VARIANT *p)
{
HTMLElement *This = impl_from_IHTMLElement3(iface);
FIXME("(%p)->(%p)\n", This, p);
return E_NOTIMPL;
}
static HRESULT WINAPI HTMLElement3_put_onmoveend(IHTMLElement3 *iface, VARIANT v)
{
HTMLElement *This = impl_from_IHTMLElement3(iface);
FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
return E_NOTIMPL;
}
static HRESULT WINAPI HTMLElement3_get_onmoveend(IHTMLElement3 *iface, VARIANT *p)
{
HTMLElement *This = impl_from_IHTMLElement3(iface);
FIXME("(%p)->(%p)\n", This, p);
return E_NOTIMPL;
}
static HRESULT WINAPI HTMLElement3_put_onmousecenter(IHTMLElement3 *iface, VARIANT v)
{
HTMLElement *This = impl_from_IHTMLElement3(iface);
FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
return E_NOTIMPL;
}
static HRESULT WINAPI HTMLElement3_get_onmousecenter(IHTMLElement3 *iface, VARIANT *p)
{
HTMLElement *This = impl_from_IHTMLElement3(iface);
FIXME("(%p)->(%p)\n", This, p);
return E_NOTIMPL;
}
static HRESULT WINAPI HTMLElement3_put_onmouseleave(IHTMLElement3 *iface, VARIANT v)
{
HTMLElement *This = impl_from_IHTMLElement3(iface);
FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
return E_NOTIMPL;
}
static HRESULT WINAPI HTMLElement3_get_onmouseleave(IHTMLElement3 *iface, VARIANT *p)
{
HTMLElement *This = impl_from_IHTMLElement3(iface);
FIXME("(%p)->(%p)\n", This, p);
return E_NOTIMPL;
}
static HRESULT WINAPI HTMLElement3_put_onactivate(IHTMLElement3 *iface, VARIANT v)
{
HTMLElement *This = impl_from_IHTMLElement3(iface);
FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
return E_NOTIMPL;
}
static HRESULT WINAPI HTMLElement3_get_onactivate(IHTMLElement3 *iface, VARIANT *p)
{
HTMLElement *This = impl_from_IHTMLElement3(iface);
FIXME("(%p)->(%p)\n", This, p);
return E_NOTIMPL;
}
static HRESULT WINAPI HTMLElement3_put_ondeactivate(IHTMLElement3 *iface, VARIANT v)
{
HTMLElement *This = impl_from_IHTMLElement3(iface);
FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
return E_NOTIMPL;
}
static HRESULT WINAPI HTMLElement3_get_ondeactivate(IHTMLElement3 *iface, VARIANT *p)
{
HTMLElement *This = impl_from_IHTMLElement3(iface);
FIXME("(%p)->(%p)\n", This, p);
return E_NOTIMPL;
}
static HRESULT WINAPI HTMLElement3_dragDrop(IHTMLElement3 *iface, VARIANT_BOOL *pfRet)
{
HTMLElement *This = impl_from_IHTMLElement3(iface);
FIXME("(%p)->(%p)\n", This, pfRet);
return E_NOTIMPL;
}
static HRESULT WINAPI HTMLElement3_get_glyphMode(IHTMLElement3 *iface, LONG *p)
{
HTMLElement *This = impl_from_IHTMLElement3(iface);
FIXME("(%p)->(%p)\n", This, p);
return E_NOTIMPL;
}
static const IHTMLElement3Vtbl HTMLElement3Vtbl = {
HTMLElement3_QueryInterface,
HTMLElement3_AddRef,
HTMLElement3_Release,
HTMLElement3_GetTypeInfoCount,
HTMLElement3_GetTypeInfo,
HTMLElement3_GetIDsOfNames,
HTMLElement3_Invoke,
HTMLElement3_mergeAttributes,
HTMLElement3_get_isMultiLine,
HTMLElement3_get_canHaveHTML,
HTMLElement3_put_onlayoutcomplete,
HTMLElement3_get_onlayoutcomplete,
HTMLElement3_put_onpage,
HTMLElement3_get_onpage,
HTMLElement3_put_inflateBlock,
HTMLElement3_get_inflateBlock,
HTMLElement3_put_onbeforedeactivate,
HTMLElement3_get_onbeforedeactivate,
HTMLElement3_setActive,
HTMLElement3_put_contentEditable,
HTMLElement3_get_contentEditable,
HTMLElement3_get_isContentEditable,
HTMLElement3_put_hideFocus,
HTMLElement3_get_hideFocus,
HTMLElement3_put_disabled,
HTMLElement3_get_disabled,
HTMLElement3_get_isDisabled,
HTMLElement3_put_onmove,
HTMLElement3_get_onmove,
HTMLElement3_put_oncontrolselect,
HTMLElement3_get_oncontrolselect,
HTMLElement3_fireEvent,
HTMLElement3_put_onresizestart,
HTMLElement3_get_onresizestart,
HTMLElement3_put_onresizeend,
HTMLElement3_get_onresizeend,
HTMLElement3_put_onmovestart,
HTMLElement3_get_onmovestart,
HTMLElement3_put_onmoveend,
HTMLElement3_get_onmoveend,
HTMLElement3_put_onmousecenter,
HTMLElement3_get_onmousecenter,
HTMLElement3_put_onmouseleave,
HTMLElement3_get_onmouseleave,
HTMLElement3_put_onactivate,
HTMLElement3_get_onactivate,
HTMLElement3_put_ondeactivate,
HTMLElement3_get_ondeactivate,
HTMLElement3_dragDrop,
HTMLElement3_get_glyphMode
};
static inline HTMLElement *impl_from_IHTMLElement4(IHTMLElement4 *iface)
{
return CONTAINING_RECORD(iface, HTMLElement, IHTMLElement4_iface);
}
static HRESULT WINAPI HTMLElement4_QueryInterface(IHTMLElement4 *iface,
REFIID riid, void **ppv)
{
HTMLElement *This = impl_from_IHTMLElement4(iface);
return IHTMLElement_QueryInterface(&This->IHTMLElement_iface, riid, ppv);
}
static ULONG WINAPI HTMLElement4_AddRef(IHTMLElement4 *iface)
{
HTMLElement *This = impl_from_IHTMLElement4(iface);
return IHTMLElement_AddRef(&This->IHTMLElement_iface);
}
static ULONG WINAPI HTMLElement4_Release(IHTMLElement4 *iface)
{
HTMLElement *This = impl_from_IHTMLElement4(iface);
return IHTMLElement_Release(&This->IHTMLElement_iface);
}
static HRESULT WINAPI HTMLElement4_GetTypeInfoCount(IHTMLElement4 *iface, UINT *pctinfo)
{
HTMLElement *This = impl_from_IHTMLElement4(iface);
return IDispatchEx_GetTypeInfoCount(&This->node.dispex.IDispatchEx_iface, pctinfo);
}
static HRESULT WINAPI HTMLElement4_GetTypeInfo(IHTMLElement4 *iface, UINT iTInfo,
LCID lcid, ITypeInfo **ppTInfo)
{
HTMLElement *This = impl_from_IHTMLElement4(iface);
return IDispatchEx_GetTypeInfo(&This->node.dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
}
static HRESULT WINAPI HTMLElement4_GetIDsOfNames(IHTMLElement4 *iface, REFIID riid,
LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
{
HTMLElement *This = impl_from_IHTMLElement4(iface);
return IDispatchEx_GetIDsOfNames(&This->node.dispex.IDispatchEx_iface, riid, rgszNames, cNames,
lcid, rgDispId);
}
static HRESULT WINAPI HTMLElement4_Invoke(IHTMLElement4 *iface, DISPID dispIdMember, REFIID riid,
LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
{
HTMLElement *This = impl_from_IHTMLElement4(iface);
return IDispatchEx_Invoke(&This->node.dispex.IDispatchEx_iface, dispIdMember, riid, lcid,
wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
}
static HRESULT WINAPI HTMLElement4_put_onmousewheel(IHTMLElement4 *iface, VARIANT v)
{
HTMLElement *This = impl_from_IHTMLElement4(iface);
FIXME("(%p)->(%s) semi-stub\n", This, debugstr_variant(&v));
return set_node_event(&This->node, EVENTID_MOUSEWHEEL, &v);
}
static HRESULT WINAPI HTMLElement4_get_onmousewheel(IHTMLElement4 *iface, VARIANT *p)
{
HTMLElement *This = impl_from_IHTMLElement4(iface);
TRACE("(%p)->(%p)\n", This, p);
return get_node_event(&This->node, EVENTID_MOUSEWHEEL, p);
}
static HRESULT WINAPI HTMLElement4_normalize(IHTMLElement4 *iface)
{
HTMLElement *This = impl_from_IHTMLElement4(iface);
FIXME("(%p)\n", This);
return E_NOTIMPL;
}
static HRESULT WINAPI HTMLElement4_getAttributeNode(IHTMLElement4 *iface, BSTR bstrname, IHTMLDOMAttribute **ppAttribute)
{
HTMLElement *This = impl_from_IHTMLElement4(iface);
HTMLAttributeCollection *attrs;
HRESULT hres;
TRACE("(%p)->(%s %p)\n", This, debugstr_w(bstrname), ppAttribute);
hres = HTMLElement_get_attr_col(&This->node, &attrs);
if(FAILED(hres))
return hres;
hres = IHTMLAttributeCollection2_getNamedItem(&attrs->IHTMLAttributeCollection2_iface, bstrname, ppAttribute);
IHTMLAttributeCollection_Release(&attrs->IHTMLAttributeCollection_iface);
return hres;
}
static HRESULT WINAPI HTMLElement4_setAttributeNode(IHTMLElement4 *iface, IHTMLDOMAttribute *pattr,
IHTMLDOMAttribute **ppretAttribute)
{
HTMLElement *This = impl_from_IHTMLElement4(iface);
FIXME("(%p)->(%p %p)\n", This, pattr, ppretAttribute);
return E_NOTIMPL;
}
static HRESULT WINAPI HTMLElement4_removeAttributeNode(IHTMLElement4 *iface, IHTMLDOMAttribute *pattr,
IHTMLDOMAttribute **ppretAttribute)
{
HTMLElement *This = impl_from_IHTMLElement4(iface);
FIXME("(%p)->(%p %p)\n", This, pattr, ppretAttribute);
return E_NOTIMPL;
}
static HRESULT WINAPI HTMLElement4_put_onbeforeactivate(IHTMLElement4 *iface, VARIANT v)
{
HTMLElement *This = impl_from_IHTMLElement4(iface);
FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
return E_NOTIMPL;
}
static HRESULT WINAPI HTMLElement4_get_onbeforeactivate(IHTMLElement4 *iface, VARIANT *p)
{
HTMLElement *This = impl_from_IHTMLElement4(iface);
FIXME("(%p)->(%p)\n", This, p);
return E_NOTIMPL;
}
static HRESULT WINAPI HTMLElement4_put_onfocusin(IHTMLElement4 *iface, VARIANT v)
{
HTMLElement *This = impl_from_IHTMLElement4(iface);
FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
return E_NOTIMPL;
}
static HRESULT WINAPI HTMLElement4_get_onfocusin(IHTMLElement4 *iface, VARIANT *p)
{
HTMLElement *This = impl_from_IHTMLElement4(iface);
FIXME("(%p)->(%p)\n", This, p);
return E_NOTIMPL;
}
static HRESULT WINAPI HTMLElement4_put_onfocusout(IHTMLElement4 *iface, VARIANT v)
{
HTMLElement *This = impl_from_IHTMLElement4(iface);
FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
return E_NOTIMPL;
}
static HRESULT WINAPI HTMLElement4_get_onfocusout(IHTMLElement4 *iface, VARIANT *p)
{
HTMLElement *This = impl_from_IHTMLElement4(iface);
FIXME("(%p)->(%p)\n", This, p);
return E_NOTIMPL;
}
static const IHTMLElement4Vtbl HTMLElement4Vtbl = {
HTMLElement4_QueryInterface,
HTMLElement4_AddRef,
HTMLElement4_Release,
HTMLElement4_GetTypeInfoCount,
HTMLElement4_GetTypeInfo,
HTMLElement4_GetIDsOfNames,
HTMLElement4_Invoke,
HTMLElement4_put_onmousewheel,
HTMLElement4_get_onmousewheel,
HTMLElement4_normalize,
HTMLElement4_getAttributeNode,
HTMLElement4_setAttributeNode,
HTMLElement4_removeAttributeNode,
HTMLElement4_put_onbeforeactivate,
HTMLElement4_get_onbeforeactivate,
HTMLElement4_put_onfocusin,
HTMLElement4_get_onfocusin,
HTMLElement4_put_onfocusout,
HTMLElement4_get_onfocusout
};
void HTMLElement3_Init(HTMLElement *This)
{
This->IHTMLElement3_iface.lpVtbl = &HTMLElement3Vtbl;
This->IHTMLElement4_iface.lpVtbl = &HTMLElement4Vtbl;
}

2
reactos/dll/win32/mshtml/htmlelemcol.c
View file

@ -204,6 +204,8 @@ static HRESULT WINAPI HTMLElementCollection_QueryInterface(IHTMLElementCollectio
{
HTMLElementCollection *This = impl_from_IHTMLElementCollection(iface);
TRACE("(%p)->(%s %p)\n", This, debugstr_mshtml_guid(riid), ppv);
if(IsEqualGUID(&IID_IUnknown, riid)) {
*ppv = &This->IHTMLElementCollection_iface;
}else if(IsEqualGUID(&IID_IHTMLElementCollection, riid)) {

9
reactos/dll/win32/mshtml/htmlevent.c
View file

@ -64,6 +64,9 @@ static const WCHAR onerrorW[] = {'o','n','e','r','r','o','r',0};
static const WCHAR focusW[] = {'f','o','c','u','s',0};
static const WCHAR onfocusW[] = {'o','n','f','o','c','u','s',0};
static const WCHAR focusinW[] = {'f','o','c','u','s','i','n',0};
static const WCHAR onfocusinW[] = {'o','n','f','o','c','u','s','i','n',0};
static const WCHAR helpW[] = {'h','e','l','p',0};
static const WCHAR onhelpW[] = {'o','n','h','e','l','p',0};
@ -173,6 +176,8 @@ static const event_info_t event_info[] = {
EVENT_BIND_TO_BODY},
{focusW, onfocusW, EVENTT_HTML, DISPID_EVMETH_ONFOCUS,
EVENT_DEFAULTLISTENER},
{focusinW, onfocusinW, EVENTT_HTML, DISPID_EVMETH_ONFOCUSIN,
EVENT_BUBBLE},
{helpW, onhelpW, EVENTT_KEY, DISPID_EVMETH_ONHELP,
EVENT_BUBBLE|EVENT_CANCELABLE},
{keydownW, onkeydownW, EVENTT_KEY, DISPID_EVMETH_ONKEYDOWN,
@ -184,7 +189,7 @@ static const event_info_t event_info[] = {
{loadW, onloadW, EVENTT_HTML, DISPID_EVMETH_ONLOAD,
EVENT_BIND_TO_BODY},
{mousedownW, onmousedownW, EVENTT_MOUSE, DISPID_EVMETH_ONMOUSEDOWN,
EVENT_DEFAULTLISTENER|EVENT_BUBBLE},
EVENT_DEFAULTLISTENER|EVENT_BUBBLE|EVENT_CANCELABLE},
{mousemoveW, onmousemoveW, EVENTT_MOUSE, DISPID_EVMETH_ONMOUSEMOVE,
EVENT_DEFAULTLISTENER|EVENT_BUBBLE},
{mouseoutW, onmouseoutW, EVENTT_MOUSE, DISPID_EVMETH_ONMOUSEOUT,
@ -534,7 +539,7 @@ static HRESULT WINAPI HTMLEventObj_get_keyCode(IHTMLEventObj *iface, LONG *p)
static HRESULT WINAPI HTMLEventObj_get_button(IHTMLEventObj *iface, LONG *p)
{
HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
UINT16 button = 0;
INT16 button = 0;
TRACE("(%p)->(%p)\n", This, p);

1
reactos/dll/win32/mshtml/htmlevent.h
View file

@ -31,6 +31,7 @@ typedef enum {
EVENTID_DRAGSTART,
EVENTID_ERROR,
EVENTID_FOCUS,
EVENTID_FOCUSIN,
EVENTID_HELP,
EVENTID_KEYDOWN,
EVENTID_KEYPRESS,

81
reactos/dll/win32/mshtml/htmlform.c
View file

@ -368,13 +368,15 @@ static HRESULT WINAPI HTMLFormElement_submit(IHTMLFormElement *iface)
{
HTMLFormElement *This = impl_from_IHTMLFormElement(iface);
HTMLOuterWindow *window = NULL, *this_window = NULL;
nsAString action_uri_str, target_str, method_str;
nsIInputStream *post_stream;
nsAString action_uri_str, target_str;
BOOL is_post_submit = FALSE;
IUri *uri;
nsresult nsres;
HRESULT hres;
BOOL use_new_window = FALSE;
TRACE("(%p)->()\n", This);
TRACE("(%p)\n", This);
if(This->element.node.doc) {
HTMLDocumentNode *doc = This->element.node.doc;
@ -388,22 +390,33 @@ static HRESULT WINAPI HTMLFormElement_submit(IHTMLFormElement *iface)
nsAString_Init(&target_str, NULL);
nsres = nsIDOMHTMLFormElement_GetTarget(This->nsform, &target_str);
if(NS_SUCCEEDED(nsres)) {
BOOL use_new_window;
if(NS_SUCCEEDED(nsres))
window = get_target_window(this_window, &target_str, &use_new_window);
if(use_new_window)
FIXME("submit to new window is not supported\n");
}
nsAString_Finish(&target_str);
if(!window)
if(!window && !use_new_window) {
nsAString_Finish(&target_str);
return S_OK;
}
nsAString_Init(&method_str, NULL);
nsres = nsIDOMHTMLFormElement_GetMethod(This->nsform, &method_str);
if(NS_SUCCEEDED(nsres)) {
const PRUnichar *method;
static const PRUnichar postW[] = {'p','o','s','t',0};
nsAString_GetData(&method_str, &method);
TRACE("method is %s\n", debugstr_w(method));
is_post_submit = !strcmpiW(method, postW);
}
nsAString_Finish(&method_str);
/*
* FIXME: We currently don't use our submit implementation for sub-windows because
* load_nsuri can't support post data. We should fix it.
* FIXME: We currently use our submit implementation for POST submit. We should always use it.
*/
if(!window->doc_obj || window->doc_obj->basedoc.window != window) {
if(window && !is_post_submit) {
nsres = nsIDOMHTMLFormElement_Submit(This->nsform);
nsAString_Finish(&target_str);
IHTMLWindow2_Release(&window->base.IHTMLWindow2_iface);
if(NS_FAILED(nsres)) {
ERR("Submit failed: %08x\n", nsres);
@ -426,13 +439,16 @@ static HRESULT WINAPI HTMLFormElement_submit(IHTMLFormElement *iface)
}
nsAString_Finish(&action_uri_str);
if(SUCCEEDED(hres)) {
window->readystate_locked++;
hres = submit_form(window, uri, post_stream);
window->readystate_locked--;
const PRUnichar *target;
nsAString_GetData(&target_str, &target);
hres = submit_form(window, target, uri, post_stream);
IUri_Release(uri);
}
IHTMLWindow2_Release(&window->base.IHTMLWindow2_iface);
nsAString_Finish(&target_str);
if(window)
IHTMLWindow2_Release(&window->base.IHTMLWindow2_iface);
if(post_stream)
nsIInputStream_Release(post_stream);
return hres;
@ -566,6 +582,9 @@ static HRESULT HTMLFormElement_QI(HTMLDOMNode *iface, REFIID riid, void **ppv)
}else if(IsEqualGUID(&IID_IHTMLFormElement, riid)) {
TRACE("(%p)->(IID_IHTMLFormElement %p)\n", This, ppv);
*ppv = &This->IHTMLFormElement_iface;
}else if(IsEqualGUID(&DIID_DispHTMLFormElement, riid)) {
TRACE("(%p)->(DIID_DispHTMLFormElement %p)\n", This, ppv);
*ppv = &This->IHTMLFormElement_iface;
}
if(*ppv) {
@ -710,6 +729,26 @@ static HRESULT HTMLFormElement_handle_event(HTMLDOMNode *iface, eventid_t eid, n
return HTMLElement_handle_event(&This->element.node, eid, event, prevent_default);
}
static void HTMLFormElement_traverse(HTMLDOMNode *iface, nsCycleCollectionTraversalCallback *cb)
{
HTMLFormElement *This = impl_from_HTMLDOMNode(iface);
if(This->nsform)
note_cc_edge((nsISupports*)This->nsform, "This->nsform", cb);
}
static void HTMLFormElement_unlink(HTMLDOMNode *iface)
{
HTMLFormElement *This = impl_from_HTMLDOMNode(iface);
if(This->nsform) {
nsIDOMHTMLFormElement *nsform = This->nsform;
This->nsform = NULL;
nsIDOMHTMLFormElement_Release(nsform);
}
}
static const NodeImplVtbl HTMLFormElementImplVtbl = {
HTMLFormElement_QI,
HTMLElement_destructor,
@ -724,7 +763,10 @@ static const NodeImplVtbl HTMLFormElementImplVtbl = {
NULL,
NULL,
HTMLFormElement_get_dispid,
HTMLFormElement_invoke
HTMLFormElement_invoke,
NULL,
HTMLFormElement_traverse,
HTMLFormElement_unlink
};
static const tid_t HTMLFormElement_iface_tids[] = {
@ -755,10 +797,7 @@ HRESULT HTMLFormElement_Create(HTMLDocumentNode *doc, nsIDOMHTMLElement *nselem,
HTMLElement_Init(&ret->element, doc, nselem, &HTMLFormElement_dispex);
nsres = nsIDOMHTMLElement_QueryInterface(nselem, &IID_nsIDOMHTMLFormElement, (void**)&ret->nsform);
/* Share the reference with nsnode */
assert(nsres == NS_OK && (nsIDOMNode*)ret->nsform == ret->element.node.nsnode);
nsIDOMNode_Release(ret->element.node.nsnode);
assert(nsres == NS_OK);
*elem = &ret->element;
return S_OK;

24
reactos/dll/win32/mshtml/htmlframe.c
View file

@ -253,6 +253,26 @@ static HRESULT HTMLFrameElement_bind_to_tree(HTMLDOMNode *iface)
return hres;
}
static void HTMLFrameElement_traverse(HTMLDOMNode *iface, nsCycleCollectionTraversalCallback *cb)
{
HTMLFrameElement *This = impl_from_HTMLDOMNode(iface);
if(This->framebase.nsframe)
note_cc_edge((nsISupports*)This->framebase.nsframe, "This->nsframe", cb);
}
static void HTMLFrameElement_unlink(HTMLDOMNode *iface)
{
HTMLFrameElement *This = impl_from_HTMLDOMNode(iface);
if(This->framebase.nsframe) {
nsIDOMHTMLFrameElement *nsframe = This->framebase.nsframe;
This->framebase.nsframe = NULL;
nsIDOMHTMLFrameElement_Release(nsframe);
}
}
static const NodeImplVtbl HTMLFrameElementImplVtbl = {
HTMLFrameElement_QI,
HTMLFrameElement_destructor,
@ -268,7 +288,9 @@ static const NodeImplVtbl HTMLFrameElementImplVtbl = {
HTMLFrameElement_get_readystate,
HTMLFrameElement_get_dispid,
HTMLFrameElement_invoke,
HTMLFrameElement_bind_to_tree
HTMLFrameElement_bind_to_tree,
HTMLFrameElement_traverse,
HTMLFrameElement_unlink
};
static const tid_t HTMLFrameElement_iface_tids[] = {

54
reactos/dll/win32/mshtml/htmlframebase.c
View file

@ -118,8 +118,21 @@ static HRESULT WINAPI HTMLFrameBase_put_src(IHTMLFrameBase *iface, BSTR v)
TRACE("(%p)->(%s)\n", This, debugstr_w(v));
if(!This->content_window || !This->element.node.doc || !This->element.node.doc->basedoc.window) {
FIXME("detached element\n");
return E_FAIL;
nsAString nsstr;
nsresult nsres;
nsAString_InitDepend(&nsstr, v);
if(This->nsframe)
nsres = nsIDOMHTMLFrameElement_SetSrc(This->nsframe, &nsstr);
else
nsres = nsIDOMHTMLIFrameElement_SetSrc(This->nsiframe, &nsstr);
nsAString_Finish(&nsstr);
if(NS_FAILED(nsres)) {
ERR("SetSrc failed: %08x\n", nsres);
return E_FAIL;
}
return S_OK;
}
return navigate_url(This->content_window, v, This->element.node.doc->basedoc.window->uri, BINDING_NAVIGATED);
@ -128,8 +141,22 @@ static HRESULT WINAPI HTMLFrameBase_put_src(IHTMLFrameBase *iface, BSTR v)
static HRESULT WINAPI HTMLFrameBase_get_src(IHTMLFrameBase *iface, BSTR *p)
{
HTMLFrameBase *This = impl_from_IHTMLFrameBase(iface);
FIXME("(%p)->(%p)\n", This, p);
return E_NOTIMPL;
nsAString nsstr;
nsresult nsres;
TRACE("(%p)->(%p)\n", This, p);
if(!This->nsframe && !This->nsiframe) {
ERR("No attached frame object\n");
return E_UNEXPECTED;
}
nsAString_Init(&nsstr, NULL);
if(This->nsframe)
nsres = nsIDOMHTMLFrameElement_GetSrc(This->nsframe, &nsstr);
else
nsres = nsIDOMHTMLIFrameElement_GetSrc(This->nsiframe, &nsstr);
return return_nsstr(nsres, &nsstr, p);
}
static HRESULT WINAPI HTMLFrameBase_put_name(IHTMLFrameBase *iface, BSTR v)
@ -624,15 +651,20 @@ static HRESULT WINAPI HTMLFrameBase2_get_readyState(IHTMLFrameBase2 *iface, BSTR
static HRESULT WINAPI HTMLFrameBase2_put_allowTransparency(IHTMLFrameBase2 *iface, VARIANT_BOOL v)
{
HTMLFrameBase *This = impl_from_IHTMLFrameBase2(iface);
FIXME("(%p)->(%x)\n", This, v);
return E_NOTIMPL;
FIXME("(%p)->(%x) semi-stub\n", This, v);
return S_OK;
}
static HRESULT WINAPI HTMLFrameBase2_get_allowTransparency(IHTMLFrameBase2 *iface, VARIANT_BOOL *p)
{
HTMLFrameBase *This = impl_from_IHTMLFrameBase2(iface);
FIXME("(%p)->(%p)\n", This, p);
return E_NOTIMPL;
FIXME("(%p)->(%p) semi-stub\n", This, p);
*p = VARIANT_TRUE;
return S_OK;
}
static const IHTMLFrameBase2Vtbl HTMLFrameBase2Vtbl = {
@ -691,12 +723,8 @@ void HTMLFrameBase_Init(HTMLFrameBase *This, HTMLDocumentNode *doc, nsIDOMHTMLEl
if(NS_FAILED(nsres)) {
This->nsframe = NULL;
nsres = nsIDOMHTMLElement_QueryInterface(nselem, &IID_nsIDOMHTMLIFrameElement, (void**)&This->nsiframe);
assert(nsres == NS_OK && (nsIDOMNode*)This->nsiframe == This->element.node.nsnode);
assert(nsres == NS_OK);
}else {
assert((nsIDOMNode*)This->nsframe == This->element.node.nsnode);
This->nsiframe = NULL;
}
/* Share the reference with nsnode */
nsIDOMNode_Release(This->element.node.nsnode);
}

24
reactos/dll/win32/mshtml/htmliframe.c
View file

@ -526,6 +526,26 @@ static HRESULT HTMLIFrame_bind_to_tree(HTMLDOMNode *iface)
return hres;
}
static void HTMLIFrame_traverse(HTMLDOMNode *iface, nsCycleCollectionTraversalCallback *cb)
{
HTMLIFrame *This = impl_from_HTMLDOMNode(iface);
if(This->framebase.nsiframe)
note_cc_edge((nsISupports*)This->framebase.nsiframe, "This->nsiframe", cb);
}
static void HTMLIFrame_unlink(HTMLDOMNode *iface)
{
HTMLIFrame *This = impl_from_HTMLDOMNode(iface);
if(This->framebase.nsiframe) {
nsIDOMHTMLIFrameElement *nsiframe = This->framebase.nsiframe;
This->framebase.nsiframe = NULL;
nsIDOMHTMLIFrameElement_Release(nsiframe);
}
}
static const NodeImplVtbl HTMLIFrameImplVtbl = {
HTMLIFrame_QI,
HTMLIFrame_destructor,
@ -541,7 +561,9 @@ static const NodeImplVtbl HTMLIFrameImplVtbl = {
HTMLIFrame_get_readystate,
HTMLIFrame_get_dispid,
HTMLIFrame_invoke,
HTMLIFrame_bind_to_tree
HTMLIFrame_bind_to_tree,
HTMLIFrame_traverse,
HTMLIFrame_unlink
};
static const tid_t HTMLIFrame_iface_tids[] = {

32
reactos/dll/win32/mshtml/htmlimg.c
View file

@ -671,6 +671,26 @@ static HRESULT HTMLImgElement_get_readystate(HTMLDOMNode *iface, BSTR *p)
return IHTMLImgElement_get_readyState(&This->IHTMLImgElement_iface, p);
}
static void HTMLImgElement_traverse(HTMLDOMNode *iface, nsCycleCollectionTraversalCallback *cb)
{
HTMLImgElement *This = impl_from_HTMLDOMNode(iface);
if(This->nsimg)
note_cc_edge((nsISupports*)This->nsimg, "This->nsimg", cb);
}
static void HTMLImgElement_unlink(HTMLDOMNode *iface)
{
HTMLImgElement *This = impl_from_HTMLDOMNode(iface);
if(This->nsimg) {
nsIDOMHTMLImageElement *nsimg = This->nsimg;
This->nsimg = NULL;
nsIDOMHTMLImageElement_Release(nsimg);
}
}
static const NodeImplVtbl HTMLImgElementImplVtbl = {
HTMLImgElement_QI,
HTMLElement_destructor,
@ -683,7 +703,12 @@ static const NodeImplVtbl HTMLImgElementImplVtbl = {
NULL,
NULL,
NULL,
HTMLImgElement_get_readystate
HTMLImgElement_get_readystate,
NULL,
NULL,
NULL,
HTMLImgElement_traverse,
HTMLImgElement_unlink
};
static const tid_t HTMLImgElement_iface_tids[] = {
@ -713,10 +738,7 @@ HRESULT HTMLImgElement_Create(HTMLDocumentNode *doc, nsIDOMHTMLElement *nselem,
HTMLElement_Init(&ret->element, doc, nselem, &HTMLImgElement_dispex);
nsres = nsIDOMHTMLElement_QueryInterface(nselem, &IID_nsIDOMHTMLImageElement, (void**)&ret->nsimg);
/* Share nsimg reference with nsnode */
assert(nsres == NS_OK && (nsIDOMNode*)ret->nsimg == ret->element.node.nsnode);
nsIDOMNode_Release(ret->element.node.nsnode);
assert(nsres == NS_OK);
*elem = &ret->element;
return S_OK;

108
reactos/dll/win32/mshtml/htmlinput.c
View file

@ -242,6 +242,7 @@ static HRESULT WINAPI HTMLInputElement_get_form(IHTMLInputElement *iface, IHTMLF
{
HTMLInputElement *This = impl_from_IHTMLInputElement(iface);
nsIDOMHTMLFormElement *nsform;
nsIDOMNode *form_node;
HTMLDOMNode *node;
HRESULT hres;
nsresult nsres;
@ -255,8 +256,12 @@ static HRESULT WINAPI HTMLInputElement_get_form(IHTMLInputElement *iface, IHTMLF
return E_FAIL;
}
hres = get_node(This->element.node.doc, (nsIDOMNode*)nsform, TRUE, &node);
nsres = nsIDOMHTMLFormElement_QueryInterface(nsform, &IID_nsIDOMNode, (void**)&form_node);
nsIDOMHTMLFormElement_Release(nsform);
assert(nsres == NS_OK);
hres = get_node(This->element.node.doc, form_node, TRUE, &node);
nsIDOMNode_Release(form_node);
if (FAILED(hres))
return hres;
@ -1219,7 +1224,7 @@ static HRESULT HTMLInputElementImpl_fire_event(HTMLDOMNode *iface, eventid_t eid
*handled = TRUE;
nsres = nsIDOMHTMLInputElement_Click(This->nsinput);
nsres = nsIDOMHTMLElement_Click(This->element.nselem);
if(NS_FAILED(nsres)) {
ERR("Click failed: %08x\n", nsres);
return E_FAIL;
@ -1241,6 +1246,52 @@ static HRESULT HTMLInputElementImpl_get_disabled(HTMLDOMNode *iface, VARIANT_BOO
return IHTMLInputElement_get_disabled(&This->IHTMLInputElement_iface, p);
}
static BOOL HTMLInputElement_is_text_edit(HTMLDOMNode *iface)
{
HTMLInputElement *This = impl_from_HTMLDOMNode(iface);
const PRUnichar *type;
nsAString nsstr;
nsresult nsres;
BOOL ret = FALSE;
static const WCHAR buttonW[] = {'b','u','t','t','o','n',0};
static const WCHAR hiddenW[] = {'h','i','d','d','e','n',0};
static const WCHAR passwordW[] = {'p','a','s','s','w','o','r','d',0};
static const WCHAR resetW[] = {'r','e','s','e','t',0};
static const WCHAR submitW[] = {'s','u','b','m','i','t',0};
static const WCHAR textW[] = {'t','e','x','t',0};
nsAString_Init(&nsstr, NULL);
nsres = nsIDOMHTMLInputElement_GetType(This->nsinput, &nsstr);
if(NS_SUCCEEDED(nsres)) {
nsAString_GetData(&nsstr, &type);
ret = !strcmpW(type, buttonW) || !strcmpW(type, hiddenW) || !strcmpW(type, passwordW)
|| !strcmpW(type, resetW) || !strcmpW(type, submitW) || !strcmpW(type, textW);
}
nsAString_Finish(&nsstr);
return ret;
}
static void HTMLInputElement_traverse(HTMLDOMNode *iface, nsCycleCollectionTraversalCallback *cb)
{
HTMLInputElement *This = impl_from_HTMLDOMNode(iface);
if(This->nsinput)
note_cc_edge((nsISupports*)This->nsinput, "This->nsinput", cb);
}
static void HTMLInputElement_unlink(HTMLDOMNode *iface)
{
HTMLInputElement *This = impl_from_HTMLDOMNode(iface);
if(This->nsinput) {
nsIDOMHTMLInputElement *nsinput = This->nsinput;
This->nsinput = NULL;
nsIDOMHTMLInputElement_Release(nsinput);
}
}
static const NodeImplVtbl HTMLInputElementImplVtbl = {
HTMLInputElement_QI,
HTMLElement_destructor,
@ -1252,6 +1303,14 @@ static const NodeImplVtbl HTMLInputElementImplVtbl = {
HTMLInputElementImpl_fire_event,
HTMLInputElementImpl_put_disabled,
HTMLInputElementImpl_get_disabled,
NULL,
NULL,
NULL,
NULL,
NULL,
HTMLInputElement_traverse,
HTMLInputElement_unlink,
HTMLInputElement_is_text_edit
};
static const tid_t HTMLInputElement_iface_tids[] = {
@ -1282,10 +1341,7 @@ HRESULT HTMLInputElement_Create(HTMLDocumentNode *doc, nsIDOMHTMLElement *nselem
HTMLElement_Init(&ret->element, doc, nselem, &HTMLInputElement_dispex);
nsres = nsIDOMHTMLElement_QueryInterface(nselem, &IID_nsIDOMHTMLInputElement, (void**)&ret->nsinput);
/* Share nsinput reference with nsnode */
assert(nsres == NS_OK && (nsIDOMNode*)ret->nsinput == ret->element.node.nsnode);
nsIDOMNode_Release(ret->element.node.nsnode);
assert(nsres == NS_OK);
*elem = &ret->element;
return S_OK;
@ -1721,6 +1777,31 @@ static HRESULT HTMLButtonElementImpl_get_disabled(HTMLDOMNode *iface, VARIANT_BO
return IHTMLButtonElement_get_disabled(&This->IHTMLButtonElement_iface, p);
}
static BOOL HTMLButtonElement_is_text_edit(HTMLDOMNode *iface)
{
return TRUE;
}
static void HTMLButtonElement_traverse(HTMLDOMNode *iface, nsCycleCollectionTraversalCallback *cb)
{
HTMLButtonElement *This = button_from_HTMLDOMNode(iface);
if(This->nsbutton)
note_cc_edge((nsISupports*)This->nsbutton, "This->nsbutton", cb);
}
static void HTMLButtonElement_unlink(HTMLDOMNode *iface)
{
HTMLButtonElement *This = button_from_HTMLDOMNode(iface);
if(This->nsbutton) {
nsIDOMHTMLButtonElement *nsbutton = This->nsbutton;
This->nsbutton = NULL;
nsIDOMHTMLButtonElement_Release(nsbutton);
}
}
static const NodeImplVtbl HTMLButtonElementImplVtbl = {
HTMLButtonElement_QI,
HTMLElement_destructor,
@ -1731,7 +1812,15 @@ static const NodeImplVtbl HTMLButtonElementImplVtbl = {
NULL,
NULL,
HTMLButtonElementImpl_put_disabled,
HTMLButtonElementImpl_get_disabled
HTMLButtonElementImpl_get_disabled,
NULL,
NULL,
NULL,
NULL,
NULL,
HTMLButtonElement_traverse,
HTMLButtonElement_unlink,
HTMLButtonElement_is_text_edit
};
static const tid_t HTMLButtonElement_iface_tids[] = {
@ -1762,10 +1851,7 @@ HRESULT HTMLButtonElement_Create(HTMLDocumentNode *doc, nsIDOMHTMLElement *nsele
HTMLElement_Init(&ret->element, doc, nselem, &HTMLButtonElement_dispex);
nsres = nsIDOMHTMLElement_QueryInterface(nselem, &IID_nsIDOMHTMLButtonElement, (void**)&ret->nsbutton);
/* Share nsbutton reference with nsnode */
assert(nsres == NS_OK && (nsIDOMNode*)ret->nsbutton == ret->element.node.nsnode);
nsIDOMNode_Release(ret->element.node.nsnode);
assert(nsres == NS_OK);
*elem = &ret->element;
return S_OK;

31
reactos/dll/win32/mshtml/htmllink.c
View file

@ -383,6 +383,25 @@ static HRESULT HTMLLinkElementImpl_get_disabled(HTMLDOMNode *iface, VARIANT_BOOL
return IHTMLLinkElement_get_disabled(&This->IHTMLLinkElement_iface, p);
}
static void HTMLLinkElement_traverse(HTMLDOMNode *iface, nsCycleCollectionTraversalCallback *cb)
{
HTMLLinkElement *This = impl_from_HTMLDOMNode(iface);
if(This->nslink)
note_cc_edge((nsISupports*)This->nslink, "This->nslink", cb);
}
static void HTMLLinkElement_unlink(HTMLDOMNode *iface)
{
HTMLLinkElement *This = impl_from_HTMLDOMNode(iface);
if(This->nslink) {
nsIDOMHTMLLinkElement *nslink = This->nslink;
This->nslink = NULL;
nsIDOMHTMLLinkElement_Release(nslink);
}
}
static const NodeImplVtbl HTMLLinkElementImplVtbl = {
HTMLLinkElement_QI,
HTMLElement_destructor,
@ -394,6 +413,13 @@ static const NodeImplVtbl HTMLLinkElementImplVtbl = {
NULL,
HTMLLinkElementImpl_put_disabled,
HTMLLinkElementImpl_get_disabled,
NULL,
NULL,
NULL,
NULL,
NULL,
HTMLLinkElement_traverse,
HTMLLinkElement_unlink
};
static const tid_t HTMLLinkElement_iface_tids[] = {
@ -423,10 +449,7 @@ HRESULT HTMLLinkElement_Create(HTMLDocumentNode *doc, nsIDOMHTMLElement *nselem,
HTMLElement_Init(&ret->element, doc, nselem, &HTMLLinkElement_dispex);
nsres = nsIDOMHTMLElement_QueryInterface(nselem, &IID_nsIDOMHTMLLinkElement, (void**)&ret->nslink);
/* Share nslink reference with nsnode */
assert(nsres == NS_OK && (nsIDOMNode*)ret->nslink == ret->element.node.nsnode);
nsIDOMNode_Release(ret->element.node.nsnode);
assert(nsres == NS_OK);
*elem = &ret->element;
return S_OK;

41
reactos/dll/win32/mshtml/htmlnode.c
View file

@ -21,6 +21,8 @@
static HTMLDOMNode *get_node_obj(IHTMLDOMNode*);
static HRESULT create_node(HTMLDocumentNode*,nsIDOMNode*,HTMLDOMNode**);
static ExternalCycleCollectionParticipant node_ccp;
typedef struct {
DispatchEx dispex;
IHTMLDOMChildrenCollection IHTMLDOMChildrenCollection_iface;
@ -462,7 +464,9 @@ static HRESULT WINAPI HTMLDOMNode_QueryInterface(IHTMLDOMNode *iface,
static ULONG WINAPI HTMLDOMNode_AddRef(IHTMLDOMNode *iface)
{
HTMLDOMNode *This = impl_from_IHTMLDOMNode(iface);
LONG ref = ccref_incr(&This->ccref, (nsISupports*)&This->IHTMLDOMNode_iface);
LONG ref;
ref = ccref_incr(&This->ccref, (nsISupports*)&This->IHTMLDOMNode_iface);
TRACE("(%p) ref=%d\n", This, ref);
@ -472,18 +476,10 @@ static ULONG WINAPI HTMLDOMNode_AddRef(IHTMLDOMNode *iface)
static ULONG WINAPI HTMLDOMNode_Release(IHTMLDOMNode *iface)
{
HTMLDOMNode *This = impl_from_IHTMLDOMNode(iface);
LONG ref = ccref_decr(&This->ccref, (nsISupports*)&This->IHTMLDOMNode_iface);
LONG ref = ccref_decr(&This->ccref, (nsISupports*)&This->IHTMLDOMNode_iface, /*&node_ccp*/ NULL);
TRACE("(%p) ref=%d\n", This, ref);
if(!ref) {
if(This->vtbl->unlink)
This->vtbl->unlink(This);
This->vtbl->destructor(This);
release_dispex(&This->dispex);
heap_free(This);
}
return ref;
}
@ -1143,8 +1139,6 @@ static const IHTMLDOMNode2Vtbl HTMLDOMNode2Vtbl = {
HTMLDOMNode2_get_ownerDocument
};
static nsXPCOMCycleCollectionParticipant node_ccp;
HRESULT HTMLDOMNode_QI(HTMLDOMNode *This, REFIID riid, void **ppv)
{
TRACE("(%p)->(%s %p)\n", This, debugstr_mshtml_guid(riid), ppv);
@ -1272,12 +1266,6 @@ static HRESULT create_node(HTMLDocumentNode *doc, nsIDOMNode *nsnode, HTMLDOMNod
return S_OK;
}
static void NSAPI HTMLDOMNode_unmark_if_purple(void *p)
{
HTMLDOMNode *This = impl_from_IHTMLDOMNode(p);
ccref_unmark_if_purple(&This->ccref);
}
static nsresult NSAPI HTMLDOMNode_traverse(void *ccp, void *p, nsCycleCollectionTraversalCallback *cb)
{
HTMLDOMNode *This = impl_from_IHTMLDOMNode(p);
@ -1326,12 +1314,25 @@ static nsresult NSAPI HTMLDOMNode_unlink(void *p)
return NS_OK;
}
static void NSAPI HTMLDOMNode_delete_cycle_collectable(void *p)
{
HTMLDOMNode *This = impl_from_IHTMLDOMNode(p);
TRACE("(%p)\n", This);
if(This->vtbl->unlink)
This->vtbl->unlink(This);
This->vtbl->destructor(This);
release_dispex(&This->dispex);
heap_free(This);
}
void init_node_cc(void)
{
static const CCObjCallback node_ccp_callback = {
HTMLDOMNode_unmark_if_purple,
HTMLDOMNode_traverse,
HTMLDOMNode_unlink
HTMLDOMNode_unlink,
HTMLDOMNode_delete_cycle_collectable
};
ccp_init(&node_ccp, &node_ccp_callback);

59
reactos/dll/win32/mshtml/htmlobject.c
View file

@ -559,8 +559,29 @@ static HRESULT WINAPI HTMLObjectElement2_namedRecordset(IHTMLObjectElement2 *ifa
static HRESULT WINAPI HTMLObjectElement2_put_classid(IHTMLObjectElement2 *iface, BSTR v)
{
HTMLObjectElement *This = impl_from_IHTMLObjectElement2(iface);
FIXME("(%p)->(%s)\n", This, debugstr_w(v));
return E_NOTIMPL;
HRESULT hres;
static const WCHAR classidW[] = {'c','l','a','s','s','i','d',0};
FIXME("(%p)->(%s) semi-stub\n", This, debugstr_w(v));
hres = elem_string_attr_setter(&This->plugin_container.element, classidW, v);
if(FAILED(hres))
return hres;
if(This->plugin_container.plugin_host) {
FIXME("Host already asociated.\n");
return E_NOTIMPL;
}
/*
* NOTE:
* If the element is not yet in DOM tree, we should embed it as soon as it's added.
* However, Gecko for some reason decides not to create NP plugin in this case,
* so this won't work.
*/
return create_plugin_host(This->plugin_container.element.node.doc, &This->plugin_container);
}
static HRESULT WINAPI HTMLObjectElement2_get_classid(IHTMLObjectElement2 *iface, BSTR *p)
@ -688,6 +709,26 @@ static HRESULT HTMLObjectElement_invoke(HTMLDOMNode *iface, DISPID id, LCID lcid
return invoke_plugin_prop(&This->plugin_container, id, lcid, flags, params, res, ei);
}
static void HTMLObjectElement_traverse(HTMLDOMNode *iface, nsCycleCollectionTraversalCallback *cb)
{
HTMLObjectElement *This = impl_from_HTMLDOMNode(iface);
if(This->nsobject)
note_cc_edge((nsISupports*)This->nsobject, "This->nsobject", cb);
}
static void HTMLObjectElement_unlink(HTMLDOMNode *iface)
{
HTMLObjectElement *This = impl_from_HTMLDOMNode(iface);
if(This->nsobject) {
nsIDOMHTMLObjectElement *nsobject = This->nsobject;
This->nsobject = NULL;
nsIDOMHTMLObjectElement_Release(nsobject);
}
}
static const NodeImplVtbl HTMLObjectElementImplVtbl = {
HTMLObjectElement_QI,
HTMLObjectElement_destructor,
@ -702,13 +743,16 @@ static const NodeImplVtbl HTMLObjectElementImplVtbl = {
NULL,
HTMLObjectElement_get_readystate,
HTMLObjectElement_get_dispid,
HTMLObjectElement_invoke
HTMLObjectElement_invoke,
NULL,
HTMLObjectElement_traverse,
HTMLObjectElement_unlink
};
static const tid_t HTMLObjectElement_iface_tids[] = {
HTMLELEMENT_TIDS,
IHTMLObjectElement_tid,
IHTMLObjectElement2_tid,
IHTMLObjectElement_tid,
HTMLELEMENT_TIDS,
0
};
static dispex_static_data_t HTMLObjectElement_dispex = {
@ -734,10 +778,7 @@ HRESULT HTMLObjectElement_Create(HTMLDocumentNode *doc, nsIDOMHTMLElement *nsele
HTMLElement_Init(&ret->plugin_container.element, doc, nselem, &HTMLObjectElement_dispex);
nsres = nsIDOMHTMLElement_QueryInterface(nselem, &IID_nsIDOMHTMLObjectElement, (void**)&ret->nsobject);
/* Share nsobject reference with nsnode */
assert(nsres == NS_OK && (nsIDOMNode*)ret->nsobject == ret->plugin_container.element.node.nsnode);
nsIDOMNode_Release(ret->plugin_container.element.node.nsnode);
assert(nsres == NS_OK);
*elem = &ret->plugin_container.element;
return S_OK;

44
reactos/dll/win32/mshtml/htmloption.c
View file

@ -195,11 +195,11 @@ static HRESULT WINAPI HTMLOptionElement_put_text(IHTMLOptionElement *iface, BSTR
while(1) {
nsIDOMNode *child;
nsres = nsIDOMHTMLOptionElement_GetFirstChild(This->nsoption, &child);
nsres = nsIDOMHTMLElement_GetFirstChild(This->element.nselem, &child);
if(NS_FAILED(nsres) || !child)
break;
nsres = nsIDOMHTMLOptionElement_RemoveChild(This->nsoption, child, &tmp);
nsres = nsIDOMHTMLElement_RemoveChild(This->element.nselem, child, &tmp);
nsIDOMNode_Release(child);
if(NS_SUCCEEDED(nsres)) {
nsIDOMNode_Release(tmp);
@ -217,7 +217,7 @@ static HRESULT WINAPI HTMLOptionElement_put_text(IHTMLOptionElement *iface, BSTR
return E_FAIL;
}
nsres = nsIDOMHTMLOptionElement_AppendChild(This->nsoption, (nsIDOMNode*)text_node, &tmp);
nsres = nsIDOMHTMLElement_AppendChild(This->element.nselem, (nsIDOMNode*)text_node, &tmp);
if(NS_SUCCEEDED(nsres))
nsIDOMNode_Release(tmp);
else
@ -297,13 +297,44 @@ static HRESULT HTMLOptionElement_QI(HTMLDOMNode *iface, REFIID riid, void **ppv)
return HTMLElement_QI(&This->element.node, riid, ppv);
}
static void HTMLOptionElement_traverse(HTMLDOMNode *iface, nsCycleCollectionTraversalCallback *cb)
{
HTMLOptionElement *This = impl_from_HTMLDOMNode(iface);
if(This->nsoption)
note_cc_edge((nsISupports*)This->nsoption, "This->nsoption", cb);
}
static void HTMLOptionElement_unlink(HTMLDOMNode *iface)
{
HTMLOptionElement *This = impl_from_HTMLDOMNode(iface);
if(This->nsoption) {
nsIDOMHTMLOptionElement *nsoption = This->nsoption;
This->nsoption = NULL;
nsIDOMHTMLOptionElement_Release(nsoption);
}
}
static const NodeImplVtbl HTMLOptionElementImplVtbl = {
HTMLOptionElement_QI,
HTMLElement_destructor,
HTMLElement_cpc,
HTMLElement_clone,
HTMLElement_handle_event,
HTMLElement_get_attr_col
HTMLElement_get_attr_col,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
HTMLOptionElement_traverse,
HTMLOptionElement_unlink
};
static const tid_t HTMLOptionElement_iface_tids[] = {
@ -333,10 +364,7 @@ HRESULT HTMLOptionElement_Create(HTMLDocumentNode *doc, nsIDOMHTMLElement *nsele
HTMLElement_Init(&ret->element, doc, nselem, &HTMLOptionElement_dispex);
nsres = nsIDOMHTMLElement_QueryInterface(nselem, &IID_nsIDOMHTMLOptionElement, (void**)&ret->nsoption);
/* Share nsoption reference with nsnode */
assert(nsres == NS_OK && (nsIDOMNode*)ret->nsoption == ret->element.node.nsnode);
nsIDOMNode_Release(ret->element.node.nsnode);
assert(nsres == NS_OK);
*elem = &ret->element;
return S_OK;

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

@ -121,7 +121,7 @@ static HRESULT WINAPI HTMLScriptElement_put_src(IHTMLScriptElement *iface, BSTR
return S_OK;
}
nsres = nsIDOMHTMLScriptElement_GetParentNode(This->nsscript, &parent);
nsres = nsIDOMHTMLElement_GetParentNode(This->element.nselem, &parent);
if(NS_FAILED(nsres) || !parent) {
TRACE("No parent, not executing\n");
This->parse_on_bind = TRUE;
@ -199,7 +199,7 @@ static HRESULT WINAPI HTMLScriptElement_put_text(IHTMLScriptElement *iface, BSTR
return E_FAIL;
}
nsres = nsIDOMHTMLScriptElement_GetParentNode(This->nsscript, &parent);
nsres = nsIDOMHTMLElement_GetParentNode(This->element.nselem, &parent);
if(NS_FAILED(nsres) || !parent) {
TRACE("No parent, not executing\n");
This->parse_on_bind = TRUE;
@ -266,22 +266,28 @@ static HRESULT WINAPI HTMLScriptElement_get_defer(IHTMLScriptElement *iface, VAR
static HRESULT WINAPI HTMLScriptElement_get_readyState(IHTMLScriptElement *iface, BSTR *p)
{
HTMLScriptElement *This = impl_from_IHTMLScriptElement(iface);
FIXME("(%p)->(%p)\n", This, p);
return E_NOTIMPL;
TRACE("(%p)->(%p)\n", This, p);
return get_readystate_string(This->readystate, p);
}
static HRESULT WINAPI HTMLScriptElement_put_onerror(IHTMLScriptElement *iface, VARIANT v)
{
HTMLScriptElement *This = impl_from_IHTMLScriptElement(iface);
FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
return E_NOTIMPL;
FIXME("(%p)->(%s) semi-stub\n", This, debugstr_variant(&v));
return set_node_event(&This->element.node, EVENTID_ERROR, &v);
}
static HRESULT WINAPI HTMLScriptElement_get_onerror(IHTMLScriptElement *iface, VARIANT *p)
{
HTMLScriptElement *This = impl_from_IHTMLScriptElement(iface);
FIXME("(%p)->(%p)\n", This, p);
return E_NOTIMPL;
TRACE("(%p)->(%p)\n", This, p);
return get_node_event(&This->element.node, EVENTID_ERROR, p);
}
static HRESULT WINAPI HTMLScriptElement_put_type(IHTMLScriptElement *iface, BSTR v)
@ -376,6 +382,26 @@ static HRESULT HTMLScriptElement_get_readystate(HTMLDOMNode *iface, BSTR *p)
return IHTMLScriptElement_get_readyState(&This->IHTMLScriptElement_iface, p);
}
static void HTMLScriptElement_traverse(HTMLDOMNode *iface, nsCycleCollectionTraversalCallback *cb)
{
HTMLScriptElement *This = impl_from_HTMLDOMNode(iface);
if(This->nsscript)
note_cc_edge((nsISupports*)This->nsscript, "This->nsscript", cb);
}
static void HTMLScriptElement_unlink(HTMLDOMNode *iface)
{
HTMLScriptElement *This = impl_from_HTMLDOMNode(iface);
if(This->nsscript) {
nsIDOMHTMLScriptElement *nsscript = This->nsscript;
This->nsscript = NULL;
nsIDOMHTMLScriptElement_Release(nsscript);
}
}
static const NodeImplVtbl HTMLScriptElementImplVtbl = {
HTMLScriptElement_QI,
HTMLElement_destructor,
@ -388,15 +414,26 @@ static const NodeImplVtbl HTMLScriptElementImplVtbl = {
NULL,
NULL,
NULL,
HTMLScriptElement_get_readystate
HTMLScriptElement_get_readystate,
NULL,
NULL,
NULL,
HTMLScriptElement_traverse,
HTMLScriptElement_unlink
};
HRESULT script_elem_from_nsscript(HTMLDocumentNode *doc, nsIDOMHTMLScriptElement *nsscript, HTMLScriptElement **ret)
{
nsIDOMNode *nsnode;
HTMLDOMNode *node;
nsresult nsres;
HRESULT hres;
hres = get_node(doc, (nsIDOMNode*)nsscript, TRUE, &node);
nsres = nsIDOMHTMLScriptElement_QueryInterface(nsscript, &IID_nsIDOMNode, (void**)&nsnode);
assert(nsres == NS_OK);
hres = get_node(doc, nsnode, TRUE, &node);
nsIDOMNode_Release(nsnode);
if(FAILED(hres))
return hres;
@ -433,10 +470,7 @@ HRESULT HTMLScriptElement_Create(HTMLDocumentNode *doc, nsIDOMHTMLElement *nsele
HTMLElement_Init(&ret->element, doc, nselem, &HTMLScriptElement_dispex);
nsres = nsIDOMHTMLElement_QueryInterface(nselem, &IID_nsIDOMHTMLScriptElement, (void**)&ret->nsscript);
/* Share nsscript reference with nsnode */
assert(nsres == NS_OK && (nsIDOMNode*)ret->nsscript == ret->element.node.nsnode);
nsIDOMNode_Release(ret->element.node.nsnode);
assert(nsres == NS_OK);
*elem = &ret->element;
return S_OK;

2
reactos/dll/win32/mshtml/htmlscript.h
View file

@ -26,6 +26,8 @@ typedef struct {
nsIDOMHTMLScriptElement *nsscript;
BOOL parsed;
BOOL parse_on_bind;
BOOL pending_readystatechange_event;
READYSTATE readystate;
} HTMLScriptElement;
typedef struct {

31
reactos/dll/win32/mshtml/htmlselect.c
View file

@ -367,6 +367,7 @@ static HRESULT WINAPI HTMLSelectElement_add(IHTMLSelectElement *iface, IHTMLElem
switch(V_VT(&before)) {
case VT_EMPTY:
case VT_ERROR:
nsres = nsIWritableVariant_SetAsEmpty(nsvariant);
break;
case VT_I2:
@ -600,6 +601,26 @@ static HRESULT HTMLSelectElement_invoke(HTMLDOMNode *iface, DISPID id, LCID lcid
return S_OK;
}
static void HTMLSelectElement_traverse(HTMLDOMNode *iface, nsCycleCollectionTraversalCallback *cb)
{
HTMLSelectElement *This = impl_from_HTMLDOMNode(iface);
if(This->nsselect)
note_cc_edge((nsISupports*)This->nsselect, "This->nsselect", cb);
}
static void HTMLSelectElement_unlink(HTMLDOMNode *iface)
{
HTMLSelectElement *This = impl_from_HTMLDOMNode(iface);
if(This->nsselect) {
nsIDOMHTMLSelectElement *nsselect = This->nsselect;
This->nsselect = NULL;
nsIDOMHTMLSelectElement_Release(nsselect);
}
}
static const NodeImplVtbl HTMLSelectElementImplVtbl = {
HTMLSelectElement_QI,
HTMLElement_destructor,
@ -614,7 +635,10 @@ static const NodeImplVtbl HTMLSelectElementImplVtbl = {
NULL,
NULL,
HTMLSelectElement_get_dispid,
HTMLSelectElement_invoke
HTMLSelectElement_invoke,
NULL,
HTMLSelectElement_traverse,
HTMLSelectElement_unlink
};
static const tid_t HTMLSelectElement_tids[] = {
@ -646,10 +670,7 @@ HRESULT HTMLSelectElement_Create(HTMLDocumentNode *doc, nsIDOMHTMLElement *nsele
nsres = nsIDOMHTMLElement_QueryInterface(nselem, &IID_nsIDOMHTMLSelectElement,
(void**)&ret->nsselect);
/* Share nsselect reference with nsnode */
assert(nsres == NS_OK && (nsIDOMNode*)ret->nsselect == ret->element.node.nsnode);
nsIDOMNode_Release(ret->element.node.nsnode);
assert(nsres == NS_OK);
*elem = &ret->element;
return S_OK;

53
reactos/dll/win32/mshtml/htmlstyle.c
View file

@ -93,6 +93,8 @@ static const WCHAR attrDisplay[] =
{'d','i','s','p','l','a','y',0};
static const WCHAR attrFilter[] =
{'f','i','l','e','t','e','r',0};
static const WCHAR attrFloat[] =
{'f','l','o','a','t',0};
static const WCHAR attrFontFamily[] =
{'f','o','n','t','-','f','a','m','i','l','y',0};
static const WCHAR attrFontSize[] =
@ -127,6 +129,10 @@ static const WCHAR attrMarginRight[] =
{'m','a','r','g','i','n','-','r','i','g','h','t',0};
static const WCHAR attrMarginTop[] =
{'m','a','r','g','i','n','-','t','o','p',0};
static const WCHAR attrMaxHeight[] =
{'m','a','x','-','h','e','i','g','h','t',0};
static const WCHAR attrMaxWidth[] =
{'m','a','x','-','w','i','d','t','h',0};
static const WCHAR attrMinHeight[] =
{'m','i','n','-','h','e','i','g','h','t',0};
static const WCHAR attrMinWidth[] =
@ -230,6 +236,7 @@ static const style_tbl_entry_t style_tbl[] = {
{attrDirection, DISPID_IHTMLSTYLE2_DIRECTION},
{attrDisplay, DISPID_IHTMLSTYLE_DISPLAY},
{attrFilter, DISPID_IHTMLSTYLE_FILTER},
{attrFloat, DISPID_IHTMLSTYLE_STYLEFLOAT},
{attrFontFamily, DISPID_IHTMLSTYLE_FONTFAMILY},
{attrFontSize, DISPID_IHTMLSTYLE_FONTSIZE},
{attrFontStyle, DISPID_IHTMLSTYLE_FONTSTYLE},
@ -247,6 +254,8 @@ static const style_tbl_entry_t style_tbl[] = {
{attrMarginLeft, DISPID_IHTMLSTYLE_MARGINLEFT},
{attrMarginRight, DISPID_IHTMLSTYLE_MARGINRIGHT},
{attrMarginTop, DISPID_IHTMLSTYLE_MARGINTOP},
{attrMaxHeight, DISPID_IHTMLSTYLE5_MAXHEIGHT},
{attrMaxWidth, DISPID_IHTMLSTYLE5_MAXWIDTH},
{attrMinHeight, DISPID_IHTMLSTYLE4_MINHEIGHT},
{attrMinWidth, DISPID_IHTMLSTYLE5_MINWIDTH},
{attrOutline, DISPID_IHTMLSTYLE6_OUTLINE},
@ -277,6 +286,8 @@ static const style_tbl_entry_t style_tbl[] = {
{attrZIndex, DISPID_IHTMLSTYLE_ZINDEX}
};
C_ASSERT(sizeof(style_tbl)/sizeof(*style_tbl) == STYLEID_MAX_VALUE);
static const WCHAR valLineThrough[] =
{'l','i','n','e','-','t','h','r','o','u','g','h',0};
static const WCHAR valUnderline[] =
@ -912,19 +923,13 @@ static HRESULT WINAPI HTMLStyle_put_fontWeight(IHTMLStyle *iface, BSTR v)
TRACE("(%p)->(%s)\n", This, debugstr_w(v));
/* fontWeight can only be one of the following */
if(!v || strcmpiW(szNormal, v) == 0 || strcmpiW(styleBold, v) == 0 ||
strcmpiW(styleBolder, v) == 0 || strcmpiW(styleLighter, v) == 0 ||
strcmpiW(style100, v) == 0 || strcmpiW(style200, v) == 0 ||
strcmpiW(style300, v) == 0 || strcmpiW(style400, v) == 0 ||
strcmpiW(style500, v) == 0 || strcmpiW(style600, v) == 0 ||
strcmpiW(style700, v) == 0 || strcmpiW(style800, v) == 0 ||
strcmpiW(style900, v) == 0
)
{
return set_nsstyle_attr(This->nsstyle, STYLEID_FONT_WEIGHT, v, 0);
}
if(v && *v && strcmpiW(szNormal, v) && strcmpiW(styleBold, v) && strcmpiW(styleBolder, v)
&& strcmpiW(styleLighter, v) && strcmpiW(style100, v) && strcmpiW(style200, v)
&& strcmpiW(style300, v) && strcmpiW(style400, v) && strcmpiW(style500, v) && strcmpiW(style600, v)
&& strcmpiW(style700, v) && strcmpiW(style800, v) && strcmpiW(style900, v))
return E_INVALIDARG;
return E_INVALIDARG;
return set_nsstyle_attr(This->nsstyle, STYLEID_FONT_WEIGHT, v, 0);
}
static HRESULT WINAPI HTMLStyle_get_fontWeight(IHTMLStyle *iface, BSTR *p)
@ -2115,15 +2120,19 @@ static HRESULT WINAPI HTMLStyle_get_height(IHTMLStyle *iface, VARIANT *p)
static HRESULT WINAPI HTMLStyle_put_styleFloat(IHTMLStyle *iface, BSTR v)
{
HTMLStyle *This = impl_from_IHTMLStyle(iface);
FIXME("(%p)->(%s)\n", This, debugstr_w(v));
return E_NOTIMPL;
TRACE("(%p)->(%s)\n", This, debugstr_w(v));
return set_style_attr(This, STYLEID_FLOAT, v, 0);
}
static HRESULT WINAPI HTMLStyle_get_styleFloat(IHTMLStyle *iface, BSTR *p)
{
HTMLStyle *This = impl_from_IHTMLStyle(iface);
FIXME("(%p)->(%p)\n", This, p);
return E_NOTIMPL;
TRACE("(%p)->(%p)\n", This, p);
return get_style_attr(This, STYLEID_FLOAT, p);
}
static HRESULT WINAPI HTMLStyle_put_clear(IHTMLStyle *iface, BSTR v)
@ -2892,7 +2901,7 @@ static HRESULT WINAPI HTMLStyle_removeAttribute(IHTMLStyle *iface, BSTR strAttri
}
if(i == sizeof(style_tbl)/sizeof(*style_tbl))
return remove_prop(&This->dispex, strAttributeName, pfSuccess);
return remove_attribute(&This->dispex, dispid, pfSuccess);
style_entry = style_tbl+i;
}
@ -3137,12 +3146,12 @@ static const dispex_static_data_vtbl_t HTMLStyle_dispex_vtbl = {
};
static const tid_t HTMLStyle_iface_tids[] = {
IHTMLStyle_tid,
IHTMLStyle2_tid,
IHTMLStyle3_tid,
IHTMLStyle4_tid,
IHTMLStyle5_tid,
IHTMLStyle6_tid,
IHTMLStyle5_tid,
IHTMLStyle4_tid,
IHTMLStyle3_tid,
IHTMLStyle2_tid,
IHTMLStyle_tid,
0
};
static dispex_static_data_t HTMLStyle_dispex = {

6
reactos/dll/win32/mshtml/htmlstyle.h
View file

@ -72,6 +72,7 @@ typedef enum {
STYLEID_DIRECTION,
STYLEID_DISPLAY,
STYLEID_FILTER,
STYLEID_FLOAT,
STYLEID_FONT_FAMILY,
STYLEID_FONT_SIZE,
STYLEID_FONT_STYLE,
@ -89,6 +90,8 @@ typedef enum {
STYLEID_MARGIN_LEFT,
STYLEID_MARGIN_RIGHT,
STYLEID_MARGIN_TOP,
STYLEID_MAX_HEIGHT,
STYLEID_MAX_WIDTH,
STYLEID_MIN_HEIGHT,
STYLEID_MIN_WIDTH,
STYLEID_OUTLINE,
@ -116,7 +119,8 @@ typedef enum {
STYLEID_WIDTH,
STYLEID_WORD_SPACING,
STYLEID_WORD_WRAP,
STYLEID_Z_INDEX
STYLEID_Z_INDEX,
STYLEID_MAX_VALUE
} styleid_t;
HRESULT HTMLStyle_Create(HTMLElement*,HTMLStyle**) DECLSPEC_HIDDEN;

56
reactos/dll/win32/mshtml/htmlstyle3.c
View file

@ -89,26 +89,46 @@ static HRESULT WINAPI HTMLStyle3_get_layoutFlow(IHTMLStyle3 *iface, BSTR *p)
return E_NOTIMPL;
}
static const WCHAR zoomW[] = {'z','o','o','m',0};
static HRESULT WINAPI HTMLStyle3_put_zoom(IHTMLStyle3 *iface, VARIANT v)
{
HTMLStyle *This = impl_from_IHTMLStyle3(iface);
VARIANT *var;
HRESULT hres;
TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
/* zoom property is IE CSS extension that is mostly used as a hack to workaround IE bugs.
* The value is set to 1 then. We can safely ignore setting zoom to 1. */
if(V_VT(&v) == VT_I4 && V_I4(&v) == 1)
return S_OK;
if(V_VT(&v) != VT_I4 || V_I4(&v) != 1)
WARN("stub for %s\n", debugstr_variant(&v));
FIXME("stub for %s\n", debugstr_variant(&v));
return E_NOTIMPL;
hres = dispex_get_dprop_ref(&This->dispex, zoomW, TRUE, &var);
if(FAILED(hres))
return hres;
return VariantChangeType(var, &v, 0, VT_BSTR);
}
static HRESULT WINAPI HTMLStyle3_get_zoom(IHTMLStyle3 *iface, VARIANT *p)
{
HTMLStyle *This = impl_from_IHTMLStyle3(iface);
FIXME("(%p)->(%p)\n", This, p);
return E_NOTIMPL;
VARIANT *var;
HRESULT hres;
TRACE("(%p)->(%p)\n", This, p);
hres = dispex_get_dprop_ref(&This->dispex, zoomW, FALSE, &var);
if(hres == DISP_E_UNKNOWNNAME) {
V_VT(p) = VT_BSTR;
V_BSTR(p) = NULL;
return S_OK;
}
if(FAILED(hres))
return hres;
return VariantCopy(p, var);
}
static HRESULT WINAPI HTMLStyle3_put_wordWrap(IHTMLStyle3 *iface, BSTR v)
@ -516,15 +536,19 @@ static HRESULT WINAPI HTMLStyle5_get_msInterpolationMode(IHTMLStyle5 *iface, BST
static HRESULT WINAPI HTMLStyle5_put_maxHeight(IHTMLStyle5 *iface, VARIANT v)
{
HTMLStyle *This = impl_from_IHTMLStyle5(iface);
FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
return E_NOTIMPL;
TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
return set_nsstyle_attr_var(This->nsstyle, STYLEID_MAX_HEIGHT, &v, ATTR_FIX_PX);
}
static HRESULT WINAPI HTMLStyle5_get_maxHeight(IHTMLStyle5 *iface, VARIANT *p)
{
HTMLStyle *This = impl_from_IHTMLStyle5(iface);
FIXME("(%p)->(%p)\n", This, p);
return E_NOTIMPL;
TRACE("(%p)->(%p)\n", This, debugstr_variant(p));
return get_nsstyle_attr_var(This->nsstyle, STYLEID_MAX_HEIGHT, p, 0);
}
static HRESULT WINAPI HTMLStyle5_put_minWidth(IHTMLStyle5 *iface, VARIANT v)
@ -548,15 +572,19 @@ static HRESULT WINAPI HTMLStyle5_get_minWidth(IHTMLStyle5 *iface, VARIANT *p)
static HRESULT WINAPI HTMLStyle5_put_maxWidth(IHTMLStyle5 *iface, VARIANT v)
{
HTMLStyle *This = impl_from_IHTMLStyle5(iface);
FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
return E_NOTIMPL;
TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
return set_nsstyle_attr_var(This->nsstyle, STYLEID_MAX_WIDTH, &v, ATTR_FIX_PX);
}
static HRESULT WINAPI HTMLStyle5_get_maxWidth(IHTMLStyle5 *iface, VARIANT *p)
{
HTMLStyle *This = impl_from_IHTMLStyle5(iface);
FIXME("(%p)->(%p)\n", This, p);
return E_NOTIMPL;
TRACE("(%p)->(%p)\n", This, p);
return get_nsstyle_attr_var(This->nsstyle, STYLEID_MAX_WIDTH, p, 0);
}
static const IHTMLStyle5Vtbl HTMLStyle5Vtbl = {

38
reactos/dll/win32/mshtml/htmlstyleelem.c
View file

@ -304,13 +304,44 @@ static void HTMLStyleElement_destructor(HTMLDOMNode *iface)
HTMLElement_destructor(iface);
}
static void HTMLStyleElement_traverse(HTMLDOMNode *iface, nsCycleCollectionTraversalCallback *cb)
{
HTMLStyleElement *This = impl_from_HTMLDOMNode(iface);
if(This->nsstyle)
note_cc_edge((nsISupports*)This->nsstyle, "This->nsstyle", cb);
}
static void HTMLStyleElement_unlink(HTMLDOMNode *iface)
{
HTMLStyleElement *This = impl_from_HTMLDOMNode(iface);
if(This->nsstyle) {
nsIDOMHTMLStyleElement *nsstyle = This->nsstyle;
This->nsstyle = NULL;
nsIDOMHTMLStyleElement_Release(nsstyle);
}
}
static const NodeImplVtbl HTMLStyleElementImplVtbl = {
HTMLStyleElement_QI,
HTMLStyleElement_destructor,
HTMLElement_cpc,
HTMLElement_clone,
HTMLElement_handle_event,
HTMLElement_get_attr_col
HTMLElement_get_attr_col,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
HTMLStyleElement_traverse,
HTMLStyleElement_unlink
};
static const tid_t HTMLStyleElement_iface_tids[] = {
@ -340,10 +371,7 @@ HRESULT HTMLStyleElement_Create(HTMLDocumentNode *doc, nsIDOMHTMLElement *nselem
HTMLElement_Init(&ret->element, doc, nselem, &HTMLStyleElement_dispex);
nsres = nsIDOMHTMLElement_QueryInterface(nselem, &IID_nsIDOMHTMLStyleElement, (void**)&ret->nsstyle);
/* Share nsstyle reference with nsnode */
assert(nsres == NS_OK && (nsIDOMNode*)ret->nsstyle == ret->element.node.nsnode);
nsIDOMNode_Release(ret->element.node.nsnode);
assert(nsres == NS_OK);
*elem = &ret->element;
return S_OK;

71
reactos/dll/win32/mshtml/htmlstylesheet.c
View file

@ -616,15 +616,70 @@ static HRESULT WINAPI HTMLStyleSheet_get_media(IHTMLStyleSheet *iface, BSTR *p)
static HRESULT WINAPI HTMLStyleSheet_put_cssText(IHTMLStyleSheet *iface, BSTR v)
{
HTMLStyleSheet *This = impl_from_IHTMLStyleSheet(iface);
FIXME("(%p)->(%s)\n", This, debugstr_w(v));
return E_NOTIMPL;
nsresult nsres;
TRACE("(%p)->(%s)\n", This, debugstr_w(v));
do {
nsres = nsIDOMCSSStyleSheet_DeleteRule(This->nsstylesheet, 0);
}while(NS_SUCCEEDED(nsres));
if(v && *v) {
nsAString nsstr;
UINT32 idx;
/* FIXME: This won't work for multiple rules in the string. */
nsAString_InitDepend(&nsstr, v);
nsres = nsIDOMCSSStyleSheet_InsertRule(This->nsstylesheet, &nsstr, 0, &idx);
nsAString_Finish(&nsstr);
if(NS_FAILED(nsres)) {
FIXME("InsertRule failed for string %s. Probably multiple rules passed.\n", debugstr_w(v));
return E_FAIL;
}
}
return S_OK;
}
static HRESULT WINAPI HTMLStyleSheet_get_cssText(IHTMLStyleSheet *iface, BSTR *p)
{
HTMLStyleSheet *This = impl_from_IHTMLStyleSheet(iface);
FIXME("(%p)->(%p)\n", This, p);
return E_NOTIMPL;
nsIDOMCSSRuleList *nslist = NULL;
nsIDOMCSSRule *nsrule;
nsAString nsstr;
UINT32 len;
nsresult nsres;
TRACE("(%p)->(%p)\n", This, p);
nsres = nsIDOMCSSStyleSheet_GetCssRules(This->nsstylesheet, &nslist);
if(NS_FAILED(nsres)) {
ERR("GetCssRules failed: %08x\n", nsres);
return E_FAIL;
}
nsres = nsIDOMCSSRuleList_GetLength(nslist, &len);
assert(nsres == NS_OK);
if(len) {
nsres = nsIDOMCSSRuleList_Item(nslist, 0, &nsrule);
if(NS_FAILED(nsres))
ERR("Item failed: %08x\n", nsres);
}
nsIDOMCSSRuleList_Release(nslist);
if(NS_FAILED(nsres))
return E_FAIL;
if(!len) {
*p = NULL;
return S_OK;
}
nsAString_Init(&nsstr, NULL);
nsres = nsIDOMCSSRule_GetCssText(nsrule, &nsstr);
nsIDOMCSSRule_Release(nsrule);
return return_nsstr(nsres, &nsstr, p);
}
static HRESULT WINAPI HTMLStyleSheet_get_rules(IHTMLStyleSheet *iface,
@ -636,11 +691,11 @@ static HRESULT WINAPI HTMLStyleSheet_get_rules(IHTMLStyleSheet *iface,
TRACE("(%p)->(%p)\n", This, p);
/* Gecko has buggy security checks and GetCssRules will fail. We have a correct
* implementation and it will work when the bug will be fixed in Gecko. */
nsres = nsIDOMCSSStyleSheet_GetCssRules(This->nsstylesheet, &nslist);
if(NS_FAILED(nsres))
WARN("GetCssRules failed: %08x\n", nsres);
if(NS_FAILED(nsres)) {
ERR("GetCssRules failed: %08x\n", nsres);
return E_FAIL;
}
*p = HTMLStyleSheetRulesCollection_Create(nslist);
return S_OK;

68
reactos/dll/win32/mshtml/htmltable.c
View file

@ -274,15 +274,37 @@ static HRESULT WINAPI HTMLTable_get_cellSpacing(IHTMLTable *iface, VARIANT *p)
static HRESULT WINAPI HTMLTable_put_cellPadding(IHTMLTable *iface, VARIANT v)
{
HTMLTable *This = impl_from_IHTMLTable(iface);
FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
return E_NOTIMPL;
nsAString val;
HRESULT hres;
nsresult nsres;
TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
hres = var2str(&v, &val);
if(FAILED(hres))
return hres;
nsres = nsIDOMHTMLTableElement_SetCellPadding(This->nstable, &val);
nsAString_Finish(&val);
if(NS_FAILED(nsres)) {
ERR("Set Width(%s) failed, err = %08x\n", debugstr_variant(&v), nsres);
return E_FAIL;
}
return S_OK;
}
static HRESULT WINAPI HTMLTable_get_cellPadding(IHTMLTable *iface, VARIANT *p)
{
HTMLTable *This = impl_from_IHTMLTable(iface);
FIXME("(%p)->(%p)\n", This, p);
return E_NOTIMPL;
nsAString val;
nsresult nsres;
TRACE("(%p)->(%p)\n", This, p);
nsAString_Init(&val, NULL);
nsres = nsIDOMHTMLTableElement_GetCellPadding(This->nstable, &val);
return return_nsstr_variant(nsres, &val, p);
}
static HRESULT WINAPI HTMLTable_put_background(IHTMLTable *iface, BSTR v)
@ -979,6 +1001,26 @@ static HRESULT HTMLTable_QI(HTMLDOMNode *iface, REFIID riid, void **ppv)
return HTMLElement_QI(&This->element.node, riid, ppv);
}
static void HTMLTable_traverse(HTMLDOMNode *iface, nsCycleCollectionTraversalCallback *cb)
{
HTMLTable *This = impl_from_HTMLDOMNode(iface);
if(This->nstable)
note_cc_edge((nsISupports*)This->nstable, "This->nstable", cb);
}
static void HTMLTable_unlink(HTMLDOMNode *iface)
{
HTMLTable *This = impl_from_HTMLDOMNode(iface);
if(This->nstable) {
nsIDOMHTMLTableElement *nstable = This->nstable;
This->nstable = NULL;
nsIDOMHTMLTableElement_Release(nstable);
}
}
static const cpc_entry_t HTMLTable_cpc[] = {
{&DIID_HTMLTableEvents},
HTMLELEMENT_CPC,
@ -991,7 +1033,18 @@ static const NodeImplVtbl HTMLTableImplVtbl = {
HTMLTable_cpc,
HTMLElement_clone,
HTMLElement_handle_event,
HTMLElement_get_attr_col
HTMLElement_get_attr_col,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
HTMLTable_traverse,
HTMLTable_unlink
};
static const tid_t HTMLTable_iface_tids[] = {
@ -1026,10 +1079,7 @@ HRESULT HTMLTable_Create(HTMLDocumentNode *doc, nsIDOMHTMLElement *nselem, HTMLE
HTMLElement_Init(&ret->element, doc, nselem, &HTMLTable_dispex);
nsres = nsIDOMHTMLElement_QueryInterface(nselem, &IID_nsIDOMHTMLTableElement, (void**)&ret->nstable);
/* Share the reference with nsnode */
assert(nsres == NS_OK && (nsIDOMNode*)ret->nstable == ret->element.node.nsnode);
nsIDOMNode_Release(ret->element.node.nsnode);
assert(nsres == NS_OK);
*elem = &ret->element;
return S_OK;

38
reactos/dll/win32/mshtml/htmltablecell.c
View file

@ -384,13 +384,44 @@ static void HTMLTableCell_destructor(HTMLDOMNode *iface)
HTMLElement_destructor(&This->element.node);
}
static void HTMLTableCell_traverse(HTMLDOMNode *iface, nsCycleCollectionTraversalCallback *cb)
{
HTMLTableCell *This = impl_from_HTMLDOMNode(iface);
if(This->nscell)
note_cc_edge((nsISupports*)This->nscell, "This->nstablecell", cb);
}
static void HTMLTableCell_unlink(HTMLDOMNode *iface)
{
HTMLTableCell *This = impl_from_HTMLDOMNode(iface);
if(This->nscell) {
nsIDOMHTMLTableCellElement *nscell = This->nscell;
This->nscell = NULL;
nsIDOMHTMLTableCellElement_Release(nscell);
}
}
static const NodeImplVtbl HTMLTableCellImplVtbl = {
HTMLTableCell_QI,
HTMLTableCell_destructor,
HTMLElement_cpc,
HTMLElement_clone,
HTMLElement_handle_event,
HTMLElement_get_attr_col
HTMLElement_get_attr_col,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
HTMLTableCell_traverse,
HTMLTableCell_unlink
};
static const tid_t HTMLTableCell_iface_tids[] = {
@ -421,10 +452,7 @@ HRESULT HTMLTableCell_Create(HTMLDocumentNode *doc, nsIDOMHTMLElement *nselem, H
HTMLElement_Init(&ret->element, doc, nselem, &HTMLTableCell_dispex);
nsres = nsIDOMHTMLElement_QueryInterface(nselem, &IID_nsIDOMHTMLTableCellElement, (void**)&ret->nscell);
/* Share nscell reference with nsnode */
assert(nsres == NS_OK && (nsIDOMNode*)ret->nscell == ret->element.node.nsnode);
nsIDOMNode_Release(ret->element.node.nsnode);
assert(nsres == NS_OK);
*elem = &ret->element;
return S_OK;

38
reactos/dll/win32/mshtml/htmltablerow.c
View file

@ -388,13 +388,44 @@ static HRESULT HTMLTableRow_QI(HTMLDOMNode *iface, REFIID riid, void **ppv)
return HTMLElement_QI(&This->element.node, riid, ppv);
}
static void HTMLTableRow_traverse(HTMLDOMNode *iface, nsCycleCollectionTraversalCallback *cb)
{
HTMLTableRow *This = impl_from_HTMLDOMNode(iface);
if(This->nsrow)
note_cc_edge((nsISupports*)This->nsrow, "This->nstablerow", cb);
}
static void HTMLTableRow_unlink(HTMLDOMNode *iface)
{
HTMLTableRow *This = impl_from_HTMLDOMNode(iface);
if(This->nsrow) {
nsIDOMHTMLTableRowElement *nsrow = This->nsrow;
This->nsrow = NULL;
nsIDOMHTMLTableRowElement_Release(nsrow);
}
}
static const NodeImplVtbl HTMLTableRowImplVtbl = {
HTMLTableRow_QI,
HTMLElement_destructor,
HTMLElement_cpc,
HTMLElement_clone,
HTMLElement_handle_event,
HTMLElement_get_attr_col
HTMLElement_get_attr_col,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
HTMLTableRow_traverse,
HTMLTableRow_unlink
};
static const tid_t HTMLTableRow_iface_tids[] = {
@ -425,10 +456,7 @@ HRESULT HTMLTableRow_Create(HTMLDocumentNode *doc, nsIDOMHTMLElement *nselem, HT
HTMLElement_Init(&ret->element, doc, nselem, &HTMLTableRow_dispex);
nsres = nsIDOMHTMLElement_QueryInterface(nselem, &IID_nsIDOMHTMLTableRowElement, (void**)&ret->nsrow);
/* Share nsrow reference with nsnode */
assert(nsres == NS_OK && (nsIDOMNode*)ret->nsrow == ret->element.node.nsnode);
nsIDOMNode_Release(ret->element.node.nsnode);
assert(nsres == NS_OK);
*elem = &ret->element;
return S_OK;

73
reactos/dll/win32/mshtml/htmltextarea.c
View file

@ -182,8 +182,34 @@ static HRESULT WINAPI HTMLTextAreaElement_get_disabled(IHTMLTextAreaElement *ifa
static HRESULT WINAPI HTMLTextAreaElement_get_form(IHTMLTextAreaElement *iface, IHTMLFormElement **p)
{
HTMLTextAreaElement *This = impl_from_IHTMLTextAreaElement(iface);
FIXME("(%p)->(%p)\n", This, p);
return E_NOTIMPL;
nsIDOMHTMLFormElement *nsform;
nsIDOMNode *nsnode;
HTMLDOMNode *node;
nsresult nsres;
HRESULT hres;
TRACE("(%p)->(%p)\n", This, p);
nsres = nsIDOMHTMLTextAreaElement_GetForm(This->nstextarea, &nsform);
assert(nsres == NS_OK);
if(!nsform) {
*p = NULL;
return S_OK;
}
nsres = nsIDOMHTMLFormElement_QueryInterface(nsform, &IID_nsIDOMNode, (void**)&nsnode);
nsIDOMHTMLFormElement_Release(nsform);
assert(nsres == NS_OK);
hres = get_node(This->element.node.doc, nsnode, TRUE, &node);
nsIDOMNode_Release(nsnode);
if(FAILED(hres))
return hres;
hres = IHTMLDOMNode_QueryInterface(&node->IHTMLDOMNode_iface, &IID_IHTMLFormElement, (void**)p);
IHTMLDOMNode_Release(&node->IHTMLDOMNode_iface);
return hres;
}
static HRESULT WINAPI HTMLTextAreaElement_put_defaultValue(IHTMLTextAreaElement *iface, BSTR v)
@ -397,6 +423,31 @@ static HRESULT HTMLTextAreaElementImpl_get_disabled(HTMLDOMNode *iface, VARIANT_
return IHTMLTextAreaElement_get_disabled(&This->IHTMLTextAreaElement_iface, p);
}
static BOOL HTMLTextAreaElement_is_text_edit(HTMLDOMNode *iface)
{
return TRUE;
}
static void HTMLTextAreaElement_traverse(HTMLDOMNode *iface, nsCycleCollectionTraversalCallback *cb)
{
HTMLTextAreaElement *This = impl_from_HTMLDOMNode(iface);
if(This->nstextarea)
note_cc_edge((nsISupports*)This->nstextarea, "This->nstextarea", cb);
}
static void HTMLTextAreaElement_unlink(HTMLDOMNode *iface)
{
HTMLTextAreaElement *This = impl_from_HTMLDOMNode(iface);
if(This->nstextarea) {
nsIDOMHTMLTextAreaElement *nstextarea = This->nstextarea;
This->nstextarea = NULL;
nsIDOMHTMLTextAreaElement_Release(nstextarea);
}
}
static const NodeImplVtbl HTMLTextAreaElementImplVtbl = {
HTMLTextAreaElement_QI,
HTMLElement_destructor,
@ -407,7 +458,15 @@ static const NodeImplVtbl HTMLTextAreaElementImplVtbl = {
NULL,
NULL,
HTMLTextAreaElementImpl_put_disabled,
HTMLTextAreaElementImpl_get_disabled
HTMLTextAreaElementImpl_get_disabled,
NULL,
NULL,
NULL,
NULL,
NULL,
HTMLTextAreaElement_traverse,
HTMLTextAreaElement_unlink,
HTMLTextAreaElement_is_text_edit
};
static const tid_t HTMLTextAreaElement_iface_tids[] = {
@ -437,12 +496,8 @@ HRESULT HTMLTextAreaElement_Create(HTMLDocumentNode *doc, nsIDOMHTMLElement *nse
HTMLElement_Init(&ret->element, doc, nselem, &HTMLTextAreaElement_dispex);
nsres = nsIDOMHTMLElement_QueryInterface(nselem, &IID_nsIDOMHTMLTextAreaElement,
(void**)&ret->nstextarea);
/* Share nstextarea reference with nsnode */
assert(nsres == NS_OK && (nsIDOMNode*)ret->nstextarea == ret->element.node.nsnode);
nsIDOMNode_Release(ret->element.node.nsnode);
nsres = nsIDOMHTMLElement_QueryInterface(nselem, &IID_nsIDOMHTMLTextAreaElement, (void**)&ret->nstextarea);
assert(nsres == NS_OK);
*elem = &ret->element;
return S_OK;

158
reactos/dll/win32/mshtml/htmltextnode.c
View file

@ -21,6 +21,7 @@
struct HTMLDOMTextNode {
HTMLDOMNode node;
IHTMLDOMTextNode IHTMLDOMTextNode_iface;
IHTMLDOMTextNode2 IHTMLDOMTextNode2_iface;
nsIDOMText *nstext;
};
@ -136,8 +137,31 @@ static HRESULT WINAPI HTMLDOMTextNode_get_length(IHTMLDOMTextNode *iface, LONG *
static HRESULT WINAPI HTMLDOMTextNode_splitText(IHTMLDOMTextNode *iface, LONG offset, IHTMLDOMNode **pRetNode)
{
HTMLDOMTextNode *This = impl_from_IHTMLDOMTextNode(iface);
FIXME("(%p)->(%d %p)\n", This, offset, pRetNode);
return E_NOTIMPL;
HTMLDOMNode *node;
nsIDOMText *text;
nsresult nsres;
HRESULT hres;
TRACE("(%p)->(%d %p)\n", This, offset, pRetNode);
nsres = nsIDOMText_SplitText(This->nstext, offset, &text);
if(NS_FAILED(nsres)) {
ERR("SplitText failed: %x08x\n", nsres);
return E_FAIL;
}
if(!text) {
*pRetNode = NULL;
return S_OK;
}
hres = get_node(This->node.doc, (nsIDOMNode*)text, TRUE, &node);
nsIDOMText_Release(text);
if(FAILED(hres))
return hres;
*pRetNode = &node->IHTMLDOMNode_iface;
return S_OK;
}
static const IHTMLDOMTextNodeVtbl HTMLDOMTextNodeVtbl = {
@ -155,6 +179,124 @@ static const IHTMLDOMTextNodeVtbl HTMLDOMTextNodeVtbl = {
HTMLDOMTextNode_splitText
};
static inline HTMLDOMTextNode *impl_from_IHTMLDOMTextNode2(IHTMLDOMTextNode2 *iface)
{
return CONTAINING_RECORD(iface, HTMLDOMTextNode, IHTMLDOMTextNode2_iface);
}
static HRESULT WINAPI HTMLDOMTextNode2_QueryInterface(IHTMLDOMTextNode2 *iface, REFIID riid, void **ppv)
{
HTMLDOMTextNode *This = impl_from_IHTMLDOMTextNode2(iface);
return IHTMLDOMNode_QueryInterface(&This->node.IHTMLDOMNode_iface, riid, ppv);
}
static ULONG WINAPI HTMLDOMTextNode2_AddRef(IHTMLDOMTextNode2 *iface)
{
HTMLDOMTextNode *This = impl_from_IHTMLDOMTextNode2(iface);
return IHTMLDOMNode_AddRef(&This->node.IHTMLDOMNode_iface);
}
static ULONG WINAPI HTMLDOMTextNode2_Release(IHTMLDOMTextNode2 *iface)
{
HTMLDOMTextNode *This = impl_from_IHTMLDOMTextNode2(iface);
return IHTMLDOMNode_Release(&This->node.IHTMLDOMNode_iface);
}
static HRESULT WINAPI HTMLDOMTextNode2_GetTypeInfoCount(IHTMLDOMTextNode2 *iface, UINT *pctinfo)
{
HTMLDOMTextNode *This = impl_from_IHTMLDOMTextNode2(iface);
return IDispatchEx_GetTypeInfoCount(&This->node.dispex.IDispatchEx_iface, pctinfo);
}
static HRESULT WINAPI HTMLDOMTextNode2_GetTypeInfo(IHTMLDOMTextNode2 *iface, UINT iTInfo,
LCID lcid, ITypeInfo **ppTInfo)
{
HTMLDOMTextNode *This = impl_from_IHTMLDOMTextNode2(iface);
return IDispatchEx_GetTypeInfo(&This->node.dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
}
static HRESULT WINAPI HTMLDOMTextNode2_GetIDsOfNames(IHTMLDOMTextNode2 *iface, REFIID riid,
LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
{
HTMLDOMTextNode *This = impl_from_IHTMLDOMTextNode2(iface);
return IDispatchEx_GetIDsOfNames(&This->node.dispex.IDispatchEx_iface, riid, rgszNames, cNames,
lcid, rgDispId);
}
static HRESULT WINAPI HTMLDOMTextNode2_Invoke(IHTMLDOMTextNode2 *iface, DISPID dispIdMember,
REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult,
EXCEPINFO *pExcepInfo, UINT *puArgErr)
{
HTMLDOMTextNode *This = impl_from_IHTMLDOMTextNode2(iface);
return IDispatchEx_Invoke(&This->node.dispex.IDispatchEx_iface, dispIdMember, riid, lcid,
wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
}
static HRESULT WINAPI HTMLDOMTextNode2_substringData(IHTMLDOMTextNode2 *iface, LONG offset, LONG count, BSTR *string)
{
HTMLDOMTextNode *This = impl_from_IHTMLDOMTextNode2(iface);
FIXME("(%p)->(%d %d %p)\n", This, offset, count, string);
return E_NOTIMPL;
}
static HRESULT WINAPI HTMLDOMTextNode2_appendData(IHTMLDOMTextNode2 *iface, BSTR string)
{
HTMLDOMTextNode *This = impl_from_IHTMLDOMTextNode2(iface);
nsAString nsstr;
nsresult nsres;
TRACE("(%p)->(%s)\n", This, debugstr_w(string));
nsAString_InitDepend(&nsstr, string);
nsres = nsIDOMText_AppendData(This->nstext, &nsstr);
nsAString_Finish(&nsstr);
if(NS_FAILED(nsres)) {
ERR("AppendData failed: %08x\n", nsres);
return E_FAIL;
}
return S_OK;
}
static HRESULT WINAPI HTMLDOMTextNode2_insertData(IHTMLDOMTextNode2 *iface, LONG offset, BSTR string)
{
HTMLDOMTextNode *This = impl_from_IHTMLDOMTextNode2(iface);
FIXME("(%p)->(%d %s)\n", This, offset, debugstr_w(string));
return E_NOTIMPL;
}
static HRESULT WINAPI HTMLDOMTextNode2_deleteData(IHTMLDOMTextNode2 *iface, LONG offset, LONG count)
{
HTMLDOMTextNode *This = impl_from_IHTMLDOMTextNode2(iface);
FIXME("(%p)->(%d %d)\n", This, offset, count);
return E_NOTIMPL;
}
static HRESULT WINAPI HTMLDOMTextNode2_replaceData(IHTMLDOMTextNode2 *iface, LONG offset, LONG count, BSTR string)
{
HTMLDOMTextNode *This = impl_from_IHTMLDOMTextNode2(iface);
FIXME("(%p)->(%d %d %s)\n", This, offset, count, debugstr_w(string));
return E_NOTIMPL;
}
static const IHTMLDOMTextNode2Vtbl HTMLDOMTextNode2Vtbl = {
HTMLDOMTextNode2_QueryInterface,
HTMLDOMTextNode2_AddRef,
HTMLDOMTextNode2_Release,
HTMLDOMTextNode2_GetTypeInfoCount,
HTMLDOMTextNode2_GetTypeInfo,
HTMLDOMTextNode2_GetIDsOfNames,
HTMLDOMTextNode2_Invoke,
HTMLDOMTextNode2_substringData,
HTMLDOMTextNode2_appendData,
HTMLDOMTextNode2_insertData,
HTMLDOMTextNode2_deleteData,
HTMLDOMTextNode2_replaceData
};
static inline HTMLDOMTextNode *impl_from_HTMLDOMNode(HTMLDOMNode *iface)
{
return CONTAINING_RECORD(iface, HTMLDOMTextNode, node);
@ -164,14 +306,14 @@ static HRESULT HTMLDOMTextNode_QI(HTMLDOMNode *iface, REFIID riid, void **ppv)
{
HTMLDOMTextNode *This = impl_from_HTMLDOMNode(iface);
*ppv = NULL;
TRACE("(%p)->(%s %p)\n", This, debugstr_mshtml_guid(riid), ppv);
if(IsEqualGUID(&IID_IHTMLDOMTextNode, riid)) {
TRACE("(%p)->(IID_IHTMLDOMTextNode %p)\n", This, ppv);
if(IsEqualGUID(&IID_IHTMLDOMTextNode, riid))
*ppv = &This->IHTMLDOMTextNode_iface;
}else {
else if(IsEqualGUID(&IID_IHTMLDOMTextNode2, riid))
*ppv = &This->IHTMLDOMTextNode2_iface;
else
return HTMLDOMNode_QI(&This->node, riid, ppv);
}
IUnknown_AddRef((IUnknown*)*ppv);
return S_OK;
@ -197,6 +339,7 @@ static const tid_t HTMLDOMTextNode_iface_tids[] = {
IHTMLDOMNode_tid,
IHTMLDOMNode2_tid,
IHTMLDOMTextNode_tid,
IHTMLDOMTextNode2_tid,
0
};
static dispex_static_data_t HTMLDOMTextNode_dispex = {
@ -217,6 +360,7 @@ HRESULT HTMLDOMTextNode_Create(HTMLDocumentNode *doc, nsIDOMNode *nsnode, HTMLDO
ret->node.vtbl = &HTMLDOMTextNodeImplVtbl;
ret->IHTMLDOMTextNode_iface.lpVtbl = &HTMLDOMTextNodeVtbl;
ret->IHTMLDOMTextNode2_iface.lpVtbl = &HTMLDOMTextNode2Vtbl;
init_dispex(&ret->node.dispex, (IUnknown*)&ret->IHTMLDOMTextNode_iface,
&HTMLDOMTextNode_dispex);

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

@ -908,6 +908,8 @@ static HRESULT WINAPI HTMLWindow2_open(IHTMLWindow2 *iface, BSTR url, BSTR name,
IUri *uri;
HRESULT hres;
static const WCHAR _selfW[] = {'_','s','e','l','f',0};
TRACE("(%p)->(%s %s %s %x %p)\n", This, debugstr_w(url), debugstr_w(name),
debugstr_w(features), replace, pomWindowResult);
@ -915,6 +917,23 @@ static HRESULT WINAPI HTMLWindow2_open(IHTMLWindow2 *iface, BSTR url, BSTR name,
return E_UNEXPECTED;
if(name && *name == '_') {
if(!strcmpW(name, _selfW)) {
if((features && *features) || replace)
FIXME("Unsupported arguments for _self target\n");
hres = IHTMLWindow2_navigate(&This->IHTMLWindow2_iface, url);
if(FAILED(hres))
return hres;
if(pomWindowResult) {
FIXME("Returning this window for _self target\n");
*pomWindowResult = &This->IHTMLWindow2_iface;
IHTMLWindow2_AddRef(*pomWindowResult);
}
return S_OK;
}
FIXME("Unsupported name %s\n", debugstr_w(name));
return E_NOTIMPL;
}
@ -943,7 +962,7 @@ static HRESULT WINAPI HTMLWindow2_open(IHTMLWindow2 *iface, BSTR url, BSTR name,
if(FAILED(hres))
return hres;
hres = navigate_new_window(window, uri, name, pomWindowResult);
hres = navigate_new_window(window, uri, name, NULL, pomWindowResult);
IUri_Release(uri);
return hres;
}
@ -1570,15 +1589,33 @@ static HRESULT WINAPI HTMLWindow3_Invoke(IHTMLWindow3 *iface, DISPID dispIdMembe
static HRESULT WINAPI HTMLWindow3_get_screenLeft(IHTMLWindow3 *iface, LONG *p)
{
HTMLWindow *This = impl_from_IHTMLWindow3(iface);
FIXME("(%p)->(%p)\n", This, p);
return E_NOTIMPL;
nsresult nsres;
TRACE("(%p)->(%p)\n", This, p);
nsres = nsIDOMWindow_GetScreenX(This->outer_window->nswindow, p);
if(NS_FAILED(nsres)) {
ERR("GetScreenX failed: %08x\n", nsres);
return E_FAIL;
}
return S_OK;
}
static HRESULT WINAPI HTMLWindow3_get_screenTop(IHTMLWindow3 *iface, LONG *p)
{
HTMLWindow *This = impl_from_IHTMLWindow3(iface);
FIXME("(%p)->(%p)\n", This, p);
return E_NOTIMPL;
nsresult nsres;
TRACE("(%p)->(%p)\n", This, p);
nsres = nsIDOMWindow_GetScreenY(This->outer_window->nswindow, p);
if(NS_FAILED(nsres)) {
ERR("GetScreenY failed: %08x\n", nsres);
return E_FAIL;
}
return S_OK;
}
static HRESULT WINAPI HTMLWindow3_attachEvent(IHTMLWindow3 *iface, BSTR event, IDispatch *pDisp, VARIANT_BOOL *pfResult)

34
reactos/dll/win32/mshtml/main.c
View file

@ -24,6 +24,7 @@
#include <advpub.h>
#include <rpcproxy.h>
#include <mlang.h>
#include <initguid.h>
HINSTANCE hInst;
@ -32,6 +33,35 @@ DWORD mshtml_tls = TLS_OUT_OF_INDEXES;
static HINSTANCE shdoclc = NULL;
static HDC display_dc;
static WCHAR *status_strings[IDS_STATUS_LAST-IDS_STATUS_FIRST+1];
static IMultiLanguage2 *mlang;
UINT cp_from_charset_string(BSTR charset)
{
MIMECSETINFO info;
HRESULT hres;
if(!mlang) {
IMultiLanguage2 *new_mlang;
hres = CoCreateInstance(&CLSID_CMultiLanguage, NULL, CLSCTX_INPROC_SERVER,
&IID_IMultiLanguage2, (void**)&new_mlang);
if(FAILED(hres)) {
ERR("Could not create CMultiLanguage instance\n");
return CP_UTF8;
}
if(InterlockedCompareExchangePointer((void**)&mlang, new_mlang, NULL))
IMultiLanguage2_Release(new_mlang);
}
hres = IMultiLanguage2_GetCharsetInfo(mlang, charset, &info);
if(FAILED(hres)) {
FIXME("GetCharsetInfo failed: %08x\n", hres);
return CP_UTF8;
}
return info.uiInternetEncoding;
}
static void thread_detach(void)
{
@ -65,6 +95,8 @@ static void process_detach(void)
TlsFree(mshtml_tls);
if(display_dc)
DeleteObject(display_dc);
if(mlang)
IMultiLanguage2_Release(mlang);
free_strings();
}
@ -512,6 +544,8 @@ const char *debugstr_mshtml_guid(const GUID *iid)
X(IID_ICustomDoc);
X(IID_IDispatch);
X(IID_IDispatchEx);
X(IID_IDispatchJS);
X(IID_UndocumentedScriptIface);
X(IID_IEnumConnections);
X(IID_IEnumVARIANT);
X(IID_IHlinkTarget);

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

@ -162,6 +162,7 @@ typedef struct event_target_t event_target_t;
XIID(IHTMLDOMNode) \
XIID(IHTMLDOMNode2) \
XIID(IHTMLDOMTextNode) \
XIID(IHTMLDOMTextNode2) \
XIID(IHTMLElement) \
XIID(IHTMLElement2) \
XIID(IHTMLElement3) \
@ -196,6 +197,7 @@ typedef struct event_target_t event_target_t;
XIID(IHTMLScreen) \
XIID(IHTMLScriptElement) \
XIID(IHTMLSelectElement) \
XIID(IHTMLSelectionObject) \
XIID(IHTMLStorage) \
XIID(IHTMLStyle) \
XIID(IHTMLStyle2) \
@ -215,6 +217,7 @@ typedef struct event_target_t event_target_t;
XIID(IHTMLTextAreaElement) \
XIID(IHTMLTextContainer) \
XIID(IHTMLTitleElement) \
XIID(IHTMLTxtRange) \
XIID(IHTMLUniqueName) \
XIID(IHTMLWindow2) \
XIID(IHTMLWindow3) \
@ -266,28 +269,29 @@ struct DispatchEx {
};
typedef struct {
void *x;
UINT_PTR x;
} nsCycleCollectingAutoRefCnt;
typedef struct {
void *x[9];
} nsXPCOMCycleCollectionParticipant;
void *vtbl;
int ref_flags;
void *callbacks;
} ExternalCycleCollectionParticipant;
typedef struct nsCycleCollectionTraversalCallback nsCycleCollectionTraversalCallback;
typedef struct {
void (NSAPI *unmark_if_purple)(void*);
nsresult (NSAPI *traverse)(void*,void*,nsCycleCollectionTraversalCallback*);
nsresult (NSAPI *unlink)(void*);
void (NSAPI *delete_cycle_collectable)(void*);
} CCObjCallback;
DEFINE_GUID(IID_nsXPCOMCycleCollectionParticipant, 0x9674489b,0x1f6f,0x4550,0xa7,0x30, 0xcc,0xae,0xdd,0x10,0x4c,0xf9);
nsrefcnt (__cdecl *ccref_incr)(nsCycleCollectingAutoRefCnt*,nsISupports*);
nsrefcnt (__cdecl *ccref_decr)(nsCycleCollectingAutoRefCnt*,nsISupports*);
nsrefcnt (__cdecl *ccref_decr)(nsCycleCollectingAutoRefCnt*,nsISupports*,ExternalCycleCollectionParticipant*);
void (__cdecl *ccref_init)(nsCycleCollectingAutoRefCnt*,nsrefcnt);
void (__cdecl *ccref_unmark_if_purple)(nsCycleCollectingAutoRefCnt*);
void (__cdecl *ccp_init)(nsXPCOMCycleCollectionParticipant*,const CCObjCallback*);
void (__cdecl *ccp_init)(ExternalCycleCollectionParticipant*,const CCObjCallback*);
void (__cdecl *describe_cc_node)(nsCycleCollectingAutoRefCnt*,const char*,nsCycleCollectionTraversalCallback*);
void (__cdecl *note_cc_edge)(nsISupports*,const char*,nsCycleCollectionTraversalCallback*);
@ -296,7 +300,7 @@ void release_dispex(DispatchEx*) DECLSPEC_HIDDEN;
BOOL dispex_query_interface(DispatchEx*,REFIID,void**) DECLSPEC_HIDDEN;
HRESULT dispex_get_dprop_ref(DispatchEx*,const WCHAR*,BOOL,VARIANT**) DECLSPEC_HIDDEN;
HRESULT get_dispids(tid_t,DWORD*,DISPID**) DECLSPEC_HIDDEN;
HRESULT remove_prop(DispatchEx*,BSTR,VARIANT_BOOL*) DECLSPEC_HIDDEN;
HRESULT remove_attribute(DispatchEx*,DISPID,VARIANT_BOOL*) DECLSPEC_HIDDEN;
HRESULT dispex_get_dynid(DispatchEx*,const WCHAR*,DISPID*) DECLSPEC_HIDDEN;
void dispex_traverse(DispatchEx*,nsCycleCollectionTraversalCallback*) DECLSPEC_HIDDEN;
void dispex_unlink(DispatchEx*) DECLSPEC_HIDDEN;
@ -664,6 +668,7 @@ typedef struct {
HRESULT (*bind_to_tree)(HTMLDOMNode*);
void (*traverse)(HTMLDOMNode*,nsCycleCollectionTraversalCallback*);
void (*unlink)(HTMLDOMNode*);
BOOL (*is_text_edit)(HTMLDOMNode*);
} NodeImplVtbl;
struct HTMLDOMNode {
@ -751,7 +756,6 @@ struct HTMLDocumentNode {
HTMLInnerWindow *window;
nsIDOMHTMLDocument *nsdoc;
nsIDOMNodeSelector *nsnode_selector;
BOOL content_ready;
event_target_t *body_event_target;
@ -767,6 +771,8 @@ struct HTMLDocumentNode {
BOOL skip_mutation_notif;
UINT charset;
struct list selection_list;
struct list range_list;
struct list plugin_hosts;
@ -775,7 +781,6 @@ struct HTMLDocumentNode {
HRESULT HTMLDocument_Create(IUnknown*,REFIID,void**) DECLSPEC_HIDDEN;
HRESULT HTMLLoadOptions_Create(IUnknown*,REFIID,void**) DECLSPEC_HIDDEN;
HRESULT create_doc_from_nsdoc(nsIDOMHTMLDocument*,HTMLDocumentObj*,HTMLInnerWindow*,HTMLDocumentNode**) DECLSPEC_HIDDEN;
HRESULT create_document_fragment(nsIDOMNode*,HTMLDocumentNode*,HTMLDocumentNode**) DECLSPEC_HIDDEN;
HRESULT HTMLOuterWindow_Create(HTMLDocumentObj*,nsIDOMWindow*,HTMLOuterWindow*,HTMLOuterWindow**) DECLSPEC_HIDDEN;
HRESULT update_window_doc(HTMLInnerWindow*) DECLSPEC_HIDDEN;
@ -825,6 +830,8 @@ void show_tooltip(HTMLDocumentObj*,DWORD,DWORD,LPCWSTR) DECLSPEC_HIDDEN;
void hide_tooltip(HTMLDocumentObj*) DECLSPEC_HIDDEN;
HRESULT get_client_disp_property(IOleClientSite*,DISPID,VARIANT*) DECLSPEC_HIDDEN;
UINT get_document_charset(HTMLDocumentNode*) DECLSPEC_HIDDEN;
HRESULT ProtocolFactory_Create(REFCLSID,REFIID,void**) DECLSPEC_HIDDEN;
BOOL load_gecko(void) DECLSPEC_HIDDEN;
@ -833,8 +840,9 @@ void register_nsservice(nsIComponentRegistrar*,nsIServiceManager*) DECLSPEC_HIDD
void init_nsio(nsIComponentManager*,nsIComponentRegistrar*) DECLSPEC_HIDDEN;
void release_nsio(void) DECLSPEC_HIDDEN;
BOOL is_gecko_path(const char*) DECLSPEC_HIDDEN;
void set_viewer_zoom(NSContainer*,float) DECLSPEC_HIDDEN;
void init_node_cc(void);
void init_node_cc(void) DECLSPEC_HIDDEN;
HRESULT nsuri_to_url(LPCWSTR,BOOL,BSTR*) DECLSPEC_HIDDEN;
@ -855,8 +863,15 @@ BOOL nsAString_Init(nsAString*,const PRUnichar*) DECLSPEC_HIDDEN;
void nsAString_InitDepend(nsAString*,const PRUnichar*) DECLSPEC_HIDDEN;
UINT32 nsAString_GetData(const nsAString*,const PRUnichar**) DECLSPEC_HIDDEN;
void nsAString_Finish(nsAString*) DECLSPEC_HIDDEN;
HRESULT return_nsstr(nsresult,nsAString*,BSTR*) DECLSPEC_HIDDEN;
static inline HRESULT return_nsstr_variant(nsresult nsres, nsAString *nsstr, VARIANT *p)
{
V_VT(p) = VT_BSTR;
return return_nsstr(nsres, nsstr, &V_BSTR(p));
}
nsICommandParams *create_nscommand_params(void) DECLSPEC_HIDDEN;
HRESULT nsnode_to_nsstring(nsIDOMNode*,nsAString*) DECLSPEC_HIDDEN;
void get_editor_controller(NSContainer*) DECLSPEC_HIDDEN;
@ -873,6 +888,7 @@ void set_download_state(HTMLDocumentObj*,int) DECLSPEC_HIDDEN;
void call_docview_84(HTMLDocumentObj*) DECLSPEC_HIDDEN;
void set_ready_state(HTMLOuterWindow*,READYSTATE) DECLSPEC_HIDDEN;
HRESULT get_readystate_string(READYSTATE,BSTR*) DECLSPEC_HIDDEN;
HRESULT HTMLSelectionObject_Create(HTMLDocumentNode*,nsISelection*,IHTMLSelectionObject**) DECLSPEC_HIDDEN;
HRESULT HTMLTxtRange_Create(HTMLDocumentNode*,nsIDOMRange*,IHTMLTxtRange**) DECLSPEC_HIDDEN;
@ -951,8 +967,6 @@ HRESULT HTMLGenericElement_Create(HTMLDocumentNode*,nsIDOMHTMLElement*,HTMLEleme
void HTMLDOMNode_Init(HTMLDocumentNode*,HTMLDOMNode*,nsIDOMNode*) DECLSPEC_HIDDEN;
void HTMLElement_Init(HTMLElement*,HTMLDocumentNode*,nsIDOMHTMLElement*,dispex_static_data_t*) DECLSPEC_HIDDEN;
void HTMLElement2_Init(HTMLElement*) DECLSPEC_HIDDEN;
void HTMLElement3_Init(HTMLElement*) DECLSPEC_HIDDEN;
void HTMLTextContainer_Init(HTMLTextContainer*,HTMLDocumentNode*,nsIDOMHTMLElement*,dispex_static_data_t*) DECLSPEC_HIDDEN;
void HTMLFrameBase_Init(HTMLFrameBase*,HTMLDocumentNode*,nsIDOMHTMLElement*,dispex_static_data_t*) DECLSPEC_HIDDEN;
@ -1030,7 +1044,7 @@ struct task_t {
LONG target_magic;
task_proc_t proc;
task_proc_t destr;
struct task_t *next;
struct list entry;
};
typedef struct {
@ -1040,8 +1054,7 @@ typedef struct {
typedef struct {
HWND thread_hwnd;
task_t *task_queue_head;
task_t *task_queue_tail;
struct list task_list;
struct list timer_list;
} thread_data_t;
@ -1051,6 +1064,7 @@ HWND get_thread_hwnd(void) DECLSPEC_HIDDEN;
LONG get_task_target_magic(void) DECLSPEC_HIDDEN;
HRESULT push_task(task_t*,task_proc_t,task_proc_t,LONG) DECLSPEC_HIDDEN;
void remove_target_tasks(LONG) DECLSPEC_HIDDEN;
void flush_pending_tasks(LONG) DECLSPEC_HIDDEN;
HRESULT set_task_timer(HTMLInnerWindow*,DWORD,BOOL,IDispatch*,LONG*) DECLSPEC_HIDDEN;
HRESULT clear_task_timer(HTMLInnerWindow*,BOOL,DWORD) DECLSPEC_HIDDEN;
@ -1070,6 +1084,9 @@ DEFINE_OLEGUID(CGID_DocHostCmdPriv, 0x000214D4L, 0, 0);
DEFINE_GUID(CLSID_JScript, 0xf414c260,0x6ac0,0x11cf, 0xb6,0xd1,0x00,0xaa,0x00,0xbb,0xbb,0x58);
DEFINE_GUID(CLSID_VBScript, 0xb54f3741,0x5b07,0x11cf, 0xa4,0xb0,0x00,0xaa,0x00,0x4a,0x55,0xe8);
DEFINE_GUID(IID_UndocumentedScriptIface,0x719c3050,0xf9d3,0x11cf,0xa4,0x93,0x00,0x40,0x05,0x23,0xa8,0xa0);
DEFINE_GUID(IID_IDispatchJS,0x719c3050,0xf9d3,0x11cf,0xa4,0x93,0x00,0x40,0x05,0x23,0xa8,0xa6);
/* memory allocation functions */
static inline void * __WINE_ALLOC_SIZE(1) heap_alloc(size_t len)
@ -1216,6 +1233,7 @@ static inline void windowref_release(windowref_t *ref)
heap_free(ref);
}
UINT cp_from_charset_string(BSTR) DECLSPEC_HIDDEN;
HDC get_display_dc(void) DECLSPEC_HIDDEN;
HINSTANCE get_shdoclc(void) DECLSPEC_HIDDEN;
void set_statustext(HTMLDocumentObj*,INT,LPCWSTR) DECLSPEC_HIDDEN;

4
reactos/dll/win32/mshtml/mutation.c
View file

@ -571,12 +571,12 @@ static void NSAPI nsDocumentObserver_EndLoad(nsIDocumentObserver *iface, nsIDocu
}
static void NSAPI nsDocumentObserver_ContentStatesChanged(nsIDocumentObserver *iface, nsIDocument *aDocument,
nsIContent *aContent, nsEventStates *aStateMask)
nsIContent *aContent, EventStates aStateMask)
{
}
static void NSAPI nsDocumentObserver_DocumentStatesChanged(nsIDocumentObserver *iface, nsIDocument *aDocument,
nsEventStates *aStateMask)
EventStates aStateMask)
{
}

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

@ -28,12 +28,6 @@
static const WCHAR emptyW[] = {0};
static const WCHAR text_htmlW[] = {'t','e','x','t','/','h','t','m','l',0};
enum {
BOM_NONE,
BOM_UTF8,
BOM_UTF16
};
struct nsProtocolStream {
nsIInputStream nsIInputStream_iface;
@ -43,17 +37,6 @@ struct nsProtocolStream {
DWORD buf_size;
};
struct BSCallbackVtbl {
void (*destroy)(BSCallback*);
HRESULT (*init_bindinfo)(BSCallback*);
HRESULT (*start_binding)(BSCallback*);
HRESULT (*stop_binding)(BSCallback*,HRESULT);
HRESULT (*read_data)(BSCallback*,IStream*);
HRESULT (*on_progress)(BSCallback*,ULONG,LPCWSTR);
HRESULT (*on_response)(BSCallback*,DWORD,LPCWSTR);
HRESULT (*beginning_transaction)(BSCallback*,WCHAR**);
};
static inline nsProtocolStream *impl_from_nsIInputStream(nsIInputStream *iface)
{
return CONTAINING_RECORD(iface, nsProtocolStream, nsIInputStream_iface);
@ -206,6 +189,8 @@ static nsProtocolStream *create_nsprotocol_stream(void)
static void release_request_data(request_data_t *request_data)
{
if(request_data->post_stream)
nsIInputStream_Release(request_data->post_stream);
heap_free(request_data->headers);
if(request_data->post_data)
GlobalFree(request_data->post_data);
@ -596,7 +581,7 @@ static const IServiceProviderVtbl ServiceProviderVtbl = {
BSCServiceProvider_QueryService
};
static void init_bscallback(BSCallback *This, const BSCallbackVtbl *vtbl, IMoniker *mon, DWORD bindf)
void init_bscallback(BSCallback *This, const BSCallbackVtbl *vtbl, IMoniker *mon, DWORD bindf)
{
This->IBindStatusCallback_iface.lpVtbl = &BindStatusCallbackVtbl;
This->IServiceProvider_iface.lpVtbl = &ServiceProviderVtbl;
@ -614,7 +599,7 @@ static void init_bscallback(BSCallback *This, const BSCallbackVtbl *vtbl, IMonik
This->mon = mon;
}
static HRESULT read_stream(BSCallback *This, IStream *stream, void *buf, DWORD size, DWORD *ret_size)
HRESULT read_stream(BSCallback *This, IStream *stream, void *buf, DWORD size, DWORD *ret_size)
{
DWORD read_size = 0, skip=0;
BYTE *data = buf;
@ -794,7 +779,7 @@ HRESULT start_binding(HTMLInnerWindow *inner_window, BSCallback *bscallback, IBi
}
if(FAILED(hres)) {
bscallback->vtbl->stop_binding(bscallback, hres);
bscallback->window = NULL;
return hres;
}
@ -802,7 +787,7 @@ HRESULT start_binding(HTMLInnerWindow *inner_window, BSCallback *bscallback, IBi
IBindCtx_Release(bctx);
if(FAILED(hres)) {
WARN("BindToStorage failed: %08x\n", hres);
bscallback->vtbl->stop_binding(bscallback, hres);
bscallback->window = NULL;
return hres;
}
@ -812,179 +797,10 @@ HRESULT start_binding(HTMLInnerWindow *inner_window, BSCallback *bscallback, IBi
return S_OK;
}
typedef struct {
BSCallback bsc;
DWORD size;
char *buf;
HRESULT hres;
} BufferBSC;
static inline BufferBSC *BufferBSC_from_BSCallback(BSCallback *iface)
{
return CONTAINING_RECORD(iface, BufferBSC, bsc);
}
static void BufferBSC_destroy(BSCallback *bsc)
{
BufferBSC *This = BufferBSC_from_BSCallback(bsc);
heap_free(This->buf);
heap_free(This);
}
static HRESULT BufferBSC_init_bindinfo(BSCallback *bsc)
{
return S_OK;
}
static HRESULT BufferBSC_start_binding(BSCallback *bsc)
{
return S_OK;
}
static HRESULT BufferBSC_stop_binding(BSCallback *bsc, HRESULT result)
{
BufferBSC *This = BufferBSC_from_BSCallback(bsc);
This->hres = result;
if(FAILED(result)) {
heap_free(This->buf);
This->buf = NULL;
This->size = 0;
}
return S_OK;
}
static HRESULT BufferBSC_read_data(BSCallback *bsc, IStream *stream)
{
BufferBSC *This = BufferBSC_from_BSCallback(bsc);
DWORD readed;
HRESULT hres;
if(!This->buf) {
This->buf = heap_alloc(128);
if(!This->buf)
return E_OUTOFMEMORY;
This->size = 128;
}
do {
if(This->bsc.readed >= This->size) {
This->size <<= 1;
This->buf = heap_realloc(This->buf, This->size);
}
hres = read_stream(&This->bsc, stream, This->buf+This->bsc.readed, This->size-This->bsc.readed, &readed);
}while(hres == S_OK);
return S_OK;
}
static HRESULT BufferBSC_on_progress(BSCallback *bsc, ULONG status_code, LPCWSTR status_text)
{
return S_OK;
}
static HRESULT BufferBSC_on_response(BSCallback *bsc, DWORD response_code,
LPCWSTR response_headers)
{
return S_OK;
}
static HRESULT BufferBSC_beginning_transaction(BSCallback *bsc, WCHAR **additional_headers)
{
return S_FALSE;
}
static const BSCallbackVtbl BufferBSCVtbl = {
BufferBSC_destroy,
BufferBSC_init_bindinfo,
BufferBSC_start_binding,
BufferBSC_stop_binding,
BufferBSC_read_data,
BufferBSC_on_progress,
BufferBSC_on_response,
BufferBSC_beginning_transaction
};
HRESULT bind_mon_to_wstr(HTMLInnerWindow *window, IMoniker *mon, WCHAR **ret)
{
BufferBSC *bsc;
int cp = CP_ACP;
WCHAR *text;
HRESULT hres;
bsc = heap_alloc_zero(sizeof(*bsc));
if(!bsc)
return E_OUTOFMEMORY;
init_bscallback(&bsc->bsc, &BufferBSCVtbl, mon, 0);
bsc->hres = E_FAIL;
hres = start_binding(window, &bsc->bsc, NULL);
if(SUCCEEDED(hres))
hres = bsc->hres;
if(FAILED(hres)) {
IBindStatusCallback_Release(&bsc->bsc.IBindStatusCallback_iface);
return hres;
}
if(!bsc->bsc.readed) {
*ret = NULL;
return S_OK;
}
switch(bsc->bsc.bom) {
case BOM_UTF16:
if(bsc->bsc.readed % sizeof(WCHAR)) {
FIXME("The buffer is not a valid utf16 string\n");
hres = E_FAIL;
break;
}
text = heap_alloc(bsc->bsc.readed+sizeof(WCHAR));
if(!text) {
hres = E_OUTOFMEMORY;
break;
}
memcpy(text, bsc->buf, bsc->bsc.readed);
text[bsc->bsc.readed/sizeof(WCHAR)] = 0;
break;
case BOM_UTF8:
cp = CP_UTF8;
/* fallthrough */
default: {
DWORD len;
len = MultiByteToWideChar(cp, 0, bsc->buf, bsc->bsc.readed, NULL, 0);
text = heap_alloc((len+1)*sizeof(WCHAR));
if(!text) {
hres = E_OUTOFMEMORY;
break;
}
MultiByteToWideChar(cp, 0, bsc->buf, bsc->bsc.readed, text, len);
text[len] = 0;
}
}
IBindStatusCallback_Release(&bsc->bsc.IBindStatusCallback_iface);
if(FAILED(hres))
return hres;
*ret = text;
return S_OK;
}
static HRESULT read_post_data_stream(nsIInputStream *stream, BOOL contains_headers, struct list *headers_list,
request_data_t *request_data)
{
nsISeekableStream *seekable_stream;
UINT64 available = 0;
UINT32 data_len = 0;
char *data, *post_data;
@ -1065,9 +881,21 @@ static HRESULT read_post_data_stream(nsIInputStream *stream, BOOL contains_heade
post_data = new_data;
}
post_data[data_len] = 0;
if(post_data)
post_data[data_len] = 0;
request_data->post_data = post_data;
request_data->post_data_len = data_len;
nsres = nsIInputStream_QueryInterface(stream, &IID_nsISeekableStream, (void**)&seekable_stream);
assert(nsres == NS_OK);
nsres = nsISeekableStream_Seek(seekable_stream, NS_SEEK_SET, 0);
assert(nsres == NS_OK);
nsISeekableStream_Release(seekable_stream);
nsIInputStream_AddRef(stream);
request_data->post_stream = stream;
TRACE("post_data = %s\n", debugstr_an(request_data->post_data, request_data->post_data_len));
return S_OK;
}
@ -1182,6 +1010,8 @@ static HRESULT read_stream_data(nsChannelBSC *This, IStream *stream)
break;
case BOM_UTF16:
This->nschannel->charset = heap_strdupA(UTF16_STR);
case BOM_NONE:
/* FIXME: Get charset from HTTP headers */;
}
if(!This->nschannel->content_type) {
@ -2125,7 +1955,7 @@ static HRESULT navigate_fragment(HTMLOuterWindow *window, IUri *uri)
sprintfW(selector, selector_formatW, frag);
nsAString_InitDepend(&selector_str, selector);
/* NOTE: Gecko doesn't set result to NULL if there is no match, so nselem must be initialized */
nsres = nsIDOMNodeSelector_QuerySelector(window->base.inner_window->doc->nsnode_selector, &selector_str, &nselem);
nsres = nsIDOMHTMLDocument_QuerySelector(window->base.inner_window->doc->nsdoc, &selector_str, &nselem);
nsAString_Finish(&selector_str);
heap_free(selector);
if(NS_SUCCEEDED(nsres) && nselem) {
@ -2267,7 +2097,7 @@ HRESULT super_navigate(HTMLOuterWindow *window, IUri *uri, DWORD flags, const WC
return hres;
}
HRESULT navigate_new_window(HTMLOuterWindow *window, IUri *uri, const WCHAR *name, IHTMLWindow2 **ret)
HRESULT navigate_new_window(HTMLOuterWindow *window, IUri *uri, const WCHAR *name, request_data_t *request_data, IHTMLWindow2 **ret)
{
IWebBrowser2 *web_browser;
IHTMLWindow2 *new_window;
@ -2275,7 +2105,12 @@ HRESULT navigate_new_window(HTMLOuterWindow *window, IUri *uri, const WCHAR *nam
nsChannelBSC *bsc;
HRESULT hres;
hres = create_channelbsc(NULL, NULL, NULL, 0, FALSE, &bsc);
if(request_data)
hres = create_channelbsc(NULL, request_data->headers,
request_data->post_data, request_data->post_data_len, FALSE,
&bsc);
else
hres = create_channelbsc(NULL, NULL, NULL, 0, FALSE, &bsc);
if(FAILED(hres))
return hres;
@ -2386,23 +2221,32 @@ static HRESULT navigate_uri(HTMLOuterWindow *window, IUri *uri, const WCHAR *dis
TRACE("%s\n", debugstr_w(display_uri));
if(window->doc_obj && window->doc_obj->webbrowser && window == window->doc_obj->basedoc.window) {
if(window->doc_obj && window->doc_obj->webbrowser) {
DWORD post_data_len = request_data ? request_data->post_data_len : 0;
void *post_data = post_data_len ? request_data->post_data : NULL;
const WCHAR *headers = request_data ? request_data->headers : NULL;
if(!(flags & BINDING_REFRESH)) {
BSTR frame_name = NULL;
BOOL cancel = FALSE;
if(window != window->doc_obj->basedoc.window) {
hres = IHTMLWindow2_get_name(&window->base.IHTMLWindow2_iface, &frame_name);
if(FAILED(hres))
return hres;
}
hres = IDocObjectService_FireBeforeNavigate2(window->doc_obj->doc_object_service, NULL, display_uri, 0x40,
NULL, post_data, post_data_len ? post_data_len+1 : 0, headers, TRUE, &cancel);
frame_name, post_data, post_data_len ? post_data_len+1 : 0, headers, TRUE, &cancel);
SysFreeString(frame_name);
if(SUCCEEDED(hres) && cancel) {
TRACE("Navigation canceled\n");
return S_OK;
}
}
return super_navigate(window, uri, flags, headers, post_data, post_data_len);
if(window == window->doc_obj->basedoc.window)
return super_navigate(window, uri, flags, headers, post_data, post_data_len);
}
if(window->doc_obj && window == window->doc_obj->basedoc.window) {
@ -2422,7 +2266,7 @@ static HRESULT navigate_uri(HTMLOuterWindow *window, IUri *uri, const WCHAR *dis
if(FAILED(hres))
return hres;
hres = load_nsuri(window, nsuri, NULL, LOAD_FLAGS_NONE);
hres = load_nsuri(window, nsuri, request_data ? request_data->post_stream : NULL, NULL, LOAD_FLAGS_NONE);
nsISupports_Release((nsISupports*)nsuri);
return hres;
}
@ -2482,23 +2326,32 @@ static HRESULT translate_uri(HTMLOuterWindow *window, IUri *orig_uri, BSTR *ret_
return S_OK;
}
HRESULT submit_form(HTMLOuterWindow *window, IUri *submit_uri, nsIInputStream *post_stream)
HRESULT submit_form(HTMLOuterWindow *window, const WCHAR *target, IUri *submit_uri, nsIInputStream *post_stream)
{
request_data_t request_data = {NULL};
BSTR display_uri;
IUri *uri;
HRESULT hres;
hres = read_post_data_stream(post_stream, TRUE, NULL, &request_data);
if(FAILED(hres))
return hres;
hres = translate_uri(window, submit_uri, &display_uri, &uri);
if(SUCCEEDED(hres)) {
hres = navigate_uri(window, uri, display_uri, &request_data, BINDING_NAVIGATED|BINDING_SUBMIT);
IUri_Release(uri);
SysFreeString(display_uri);
}
if(window) {
IUri *uri;
BSTR display_uri;
window->readystate_locked++;
hres = translate_uri(window, submit_uri, &display_uri, &uri);
if(SUCCEEDED(hres)) {
hres = navigate_uri(window, uri, display_uri, &request_data, BINDING_NAVIGATED|BINDING_SUBMIT);
IUri_Release(uri);
SysFreeString(display_uri);
}
window->readystate_locked--;
}else
hres = navigate_new_window(window, submit_uri, target, &request_data, NULL);
release_request_data(&request_data);
return hres;
}

411
reactos/dll/win32/mshtml/npplugin.c
View file

@ -247,386 +247,15 @@ static HTMLInnerWindow *get_elem_window(nsIDOMHTMLElement *elem)
return window->base.inner_window;
}
static BOOL parse_classid(const PRUnichar *classid, CLSID *clsid)
{
const WCHAR *ptr;
unsigned len;
HRESULT hres;
static const PRUnichar clsidW[] = {'c','l','s','i','d',':'};
if(strncmpiW(classid, clsidW, sizeof(clsidW)/sizeof(WCHAR)))
return FALSE;
ptr = classid + sizeof(clsidW)/sizeof(WCHAR);
len = strlenW(ptr);
if(len == 38) {
hres = CLSIDFromString(ptr, clsid);
}else if(len == 36) {
WCHAR buf[39];
buf[0] = '{';
memcpy(buf+1, ptr, len*sizeof(WCHAR));
buf[37] = '}';
buf[38] = 0;
hres = CLSIDFromString(buf, clsid);
}else {
return FALSE;
}
return SUCCEEDED(hres);
}
static BOOL get_elem_clsid(nsIDOMHTMLElement *elem, CLSID *clsid)
{
const PRUnichar *val;
nsAString val_str;
nsresult nsres;
BOOL ret = FALSE;
static const PRUnichar classidW[] = {'c','l','a','s','s','i','d',0};
nsres = get_elem_attr_value(elem, classidW, &val_str, &val);
if(NS_SUCCEEDED(nsres)) {
if(*val)
ret = parse_classid(val, clsid);
nsAString_Finish(&val_str);
}
return ret;
}
typedef struct {
IBindStatusCallback IBindStatusCallback_iface;
IWindowForBindingUI IWindowForBindingUI_iface;
LONG ref;
} InstallCallback;
static inline InstallCallback *impl_from_IBindStatusCallback(IBindStatusCallback *iface)
{
return CONTAINING_RECORD(iface, InstallCallback, IBindStatusCallback_iface);
}
static HRESULT WINAPI InstallCallback_QueryInterface(IBindStatusCallback *iface,
REFIID riid, void **ppv)
{
InstallCallback *This = impl_from_IBindStatusCallback(iface);
if(IsEqualGUID(&IID_IUnknown, riid)) {
TRACE("(%p)->(IID_IUnknown %p)\n", This, ppv);
*ppv = &This->IBindStatusCallback_iface;
}else if(IsEqualGUID(&IID_IBindStatusCallback, riid)) {
TRACE("(%p)->(IID_IBindStatusCallback %p)\n", This, ppv);
*ppv = &This->IBindStatusCallback_iface;
}else if(IsEqualGUID(&IID_IWindowForBindingUI, riid)) {
TRACE("(%p)->(IID_IWindowForBindingUI %p)\n", This, ppv);
*ppv = &This->IWindowForBindingUI_iface;
}else {
TRACE("(%p)->(%s %p)\n", This, debugstr_guid(riid), ppv);
*ppv = NULL;
return E_NOINTERFACE;
}
IUnknown_AddRef((IUnknown*)*ppv);
return S_OK;
}
static ULONG WINAPI InstallCallback_AddRef(IBindStatusCallback *iface)
{
InstallCallback *This = impl_from_IBindStatusCallback(iface);
LONG ref = InterlockedIncrement(&This->ref);
TRACE("(%p) ref=%d\n", This, ref);
return ref;
}
static ULONG WINAPI InstallCallback_Release(IBindStatusCallback *iface)
{
InstallCallback *This = impl_from_IBindStatusCallback(iface);
LONG ref = InterlockedIncrement(&This->ref);
TRACE("(%p) ref=%d\n", This, ref);
if(!ref)
heap_free(This);
return ref;
}
static HRESULT WINAPI InstallCallback_OnStartBinding(IBindStatusCallback *iface,
DWORD dwReserved, IBinding *pib)
{
InstallCallback *This = impl_from_IBindStatusCallback(iface);
TRACE("(%p)->(%x %p)\n", This, dwReserved, pib);
return S_OK;
}
static HRESULT WINAPI InstallCallback_GetPriority(IBindStatusCallback *iface, LONG *pnPriority)
{
InstallCallback *This = impl_from_IBindStatusCallback(iface);
TRACE("(%p)->(%p)\n", This, pnPriority);
return E_NOTIMPL;
}
static HRESULT WINAPI InstallCallback_OnLowResource(IBindStatusCallback *iface, DWORD dwReserved)
{
InstallCallback *This = impl_from_IBindStatusCallback(iface);
TRACE("(%p)->(%x)\n", This, dwReserved);
return S_OK;
}
static HRESULT WINAPI InstallCallback_OnProgress(IBindStatusCallback *iface, ULONG ulProgress,
ULONG ulProgressMax, ULONG ulStatusCode, LPCWSTR szStatusText)
{
InstallCallback *This = impl_from_IBindStatusCallback(iface);
TRACE("(%p)->(%u %u %u %s)\n", This, ulProgress, ulProgressMax, ulStatusCode, debugstr_w(szStatusText));
return S_OK;
}
static HRESULT WINAPI InstallCallback_OnStopBinding(IBindStatusCallback *iface,
HRESULT hresult, LPCWSTR szError)
{
InstallCallback *This = impl_from_IBindStatusCallback(iface);
TRACE("(%p)->(%08x %s)\n", This, hresult, debugstr_w(szError));
return S_OK;
}
static HRESULT WINAPI InstallCallback_GetBindInfo(IBindStatusCallback *iface,
DWORD* grfBINDF, BINDINFO* pbindinfo)
{
InstallCallback *This = impl_from_IBindStatusCallback(iface);
TRACE("(%p)->(%p %p)\n", This, grfBINDF, pbindinfo);
*grfBINDF = BINDF_ASYNCHRONOUS;
return S_OK;
}
static HRESULT WINAPI InstallCallback_OnDataAvailable(IBindStatusCallback *iface, DWORD grfBSCF,
DWORD dwSize, FORMATETC* pformatetc, STGMEDIUM* pstgmed)
{
InstallCallback *This = impl_from_IBindStatusCallback(iface);
ERR("(%p)\n", This);
return E_NOTIMPL;
}
static HRESULT WINAPI InstallCallback_OnObjectAvailable(IBindStatusCallback *iface,
REFIID riid, IUnknown* punk)
{
InstallCallback *This = impl_from_IBindStatusCallback(iface);
ERR("(%p)\n", This);
return E_NOTIMPL;
}
static IBindStatusCallbackVtbl InstallCallbackVtbl = {
InstallCallback_QueryInterface,
InstallCallback_AddRef,
InstallCallback_Release,
InstallCallback_OnStartBinding,
InstallCallback_GetPriority,
InstallCallback_OnLowResource,
InstallCallback_OnProgress,
InstallCallback_OnStopBinding,
InstallCallback_GetBindInfo,
InstallCallback_OnDataAvailable,
InstallCallback_OnObjectAvailable
};
static inline InstallCallback *impl_from_IWindowForBindingUI(IWindowForBindingUI *iface)
{
return CONTAINING_RECORD(iface, InstallCallback, IWindowForBindingUI_iface);
}
static HRESULT WINAPI WindowForBindingUI_QueryInterface(IWindowForBindingUI *iface, REFIID riid, void **ppv)
{
InstallCallback *This = impl_from_IWindowForBindingUI(iface);
return IBindStatusCallback_QueryInterface(&This->IBindStatusCallback_iface, riid, ppv);
}
static ULONG WINAPI WindowForBindingUI_AddRef(IWindowForBindingUI *iface)
{
InstallCallback *This = impl_from_IWindowForBindingUI(iface);
return IBindStatusCallback_AddRef(&This->IBindStatusCallback_iface);
}
static ULONG WINAPI WindowForBindingUI_Release(IWindowForBindingUI *iface)
{
InstallCallback *This = impl_from_IWindowForBindingUI(iface);
return IBindStatusCallback_Release(&This->IBindStatusCallback_iface);
}
static HRESULT WINAPI WindowForBindingUI_GetWindow(IWindowForBindingUI *iface, REFGUID rguidReason, HWND *phwnd)
{
InstallCallback *This = impl_from_IWindowForBindingUI(iface);
FIXME("(%p)->(%s %p)\n", This, debugstr_guid(rguidReason), phwnd);
*phwnd = NULL;
return S_OK;
}
static const IWindowForBindingUIVtbl WindowForBindingUIVtbl = {
WindowForBindingUI_QueryInterface,
WindowForBindingUI_AddRef,
WindowForBindingUI_Release,
WindowForBindingUI_GetWindow
};
typedef struct {
struct list entry;
IUri *uri;
} install_entry_t;
static struct list install_list = LIST_INIT(install_list);
static CRITICAL_SECTION cs_install_list;
static CRITICAL_SECTION_DEBUG cs_install_list_dbg =
{
0, 0, &cs_install_list,
{ &cs_install_list_dbg.ProcessLocksList, &cs_install_list_dbg.ProcessLocksList },
0, 0, { (DWORD_PTR)(__FILE__ ": install_list") }
};
static CRITICAL_SECTION cs_install_list = { &cs_install_list_dbg, -1, 0, 0, 0, 0 };
static void install_codebase(const WCHAR *url)
{
InstallCallback *callback;
IBindCtx *bctx;
HRESULT hres;
callback = heap_alloc(sizeof(*callback));
if(!callback)
return;
callback->IBindStatusCallback_iface.lpVtbl = &InstallCallbackVtbl;
callback->IWindowForBindingUI_iface.lpVtbl = &WindowForBindingUIVtbl;
callback->ref = 1;
hres = CreateAsyncBindCtx(0, &callback->IBindStatusCallback_iface, NULL, &bctx);
IBindStatusCallback_Release(&callback->IBindStatusCallback_iface);
if(FAILED(hres))
return;
hres = AsyncInstallDistributionUnit(NULL, NULL, NULL, 0, 0, url, bctx, NULL, 0);
IBindCtx_Release(bctx);
if(FAILED(hres))
WARN("FAILED: %08x\n", hres);
}
static void check_codebase(HTMLInnerWindow *window, nsIDOMHTMLElement *nselem)
{
BOOL is_on_list = FALSE;
install_entry_t *iter;
const PRUnichar *val;
nsAString val_str;
IUri *uri = NULL;
nsresult nsres;
HRESULT hres;
static const PRUnichar codebaseW[] = {'c','o','d','e','b','a','s','e',0};
nsres = get_elem_attr_value(nselem, codebaseW, &val_str, &val);
if(NS_SUCCEEDED(nsres)) {
if(*val) {
hres = CoInternetCombineUrlEx(window->base.outer_window->uri, val, 0, &uri, 0);
if(FAILED(hres))
uri = NULL;
}
nsAString_Finish(&val_str);
}
if(!uri)
return;
EnterCriticalSection(&cs_install_list);
LIST_FOR_EACH_ENTRY(iter, &install_list, install_entry_t, entry) {
BOOL eq;
hres = IUri_IsEqual(uri, iter->uri, &eq);
if(SUCCEEDED(hres) && eq) {
TRACE("already proceeded\n");
is_on_list = TRUE;
break;
}
}
if(!is_on_list) {
iter = heap_alloc(sizeof(*iter));
if(iter) {
IUri_AddRef(uri);
iter->uri = uri;
list_add_tail(&install_list, &iter->entry);
}
}
LeaveCriticalSection(&cs_install_list);
if(!is_on_list) {
BSTR display_uri;
hres = IUri_GetDisplayUri(uri, &display_uri);
if(SUCCEEDED(hres)) {
install_codebase(display_uri);
SysFreeString(display_uri);
}
}
IUri_Release(uri);
}
static IUnknown *create_activex_object(HTMLInnerWindow *window, nsIDOMHTMLElement *nselem, CLSID *clsid)
{
IClassFactoryEx *cfex;
IClassFactory *cf;
IUnknown *obj;
DWORD policy;
HRESULT hres;
if(!get_elem_clsid(nselem, clsid)) {
WARN("Could not determine element CLSID\n");
return NULL;
}
TRACE("clsid %s\n", debugstr_guid(clsid));
policy = 0;
hres = IInternetHostSecurityManager_ProcessUrlAction(&window->doc->IInternetHostSecurityManager_iface,
URLACTION_ACTIVEX_RUN, (BYTE*)&policy, sizeof(policy), (BYTE*)clsid, sizeof(GUID), 0, 0);
if(FAILED(hres) || policy != URLPOLICY_ALLOW) {
WARN("ProcessUrlAction returned %08x %x\n", hres, policy);
return NULL;
}
hres = CoGetClassObject(clsid, CLSCTX_INPROC_SERVER|CLSCTX_LOCAL_SERVER, NULL, &IID_IClassFactory, (void**)&cf);
if(hres == REGDB_E_CLASSNOTREG)
check_codebase(window, nselem);
if(FAILED(hres))
return NULL;
hres = IClassFactory_QueryInterface(cf, &IID_IClassFactoryEx, (void**)&cfex);
if(SUCCEEDED(hres)) {
FIXME("Use IClassFactoryEx\n");
IClassFactoryEx_Release(cfex);
}
hres = IClassFactory_CreateInstance(cf, NULL, &IID_IUnknown, (void**)&obj);
IClassFactory_Release(cf);
if(FAILED(hres))
return NULL;
return obj;
}
static NPError CDECL NPP_New(NPMIMEType pluginType, NPP instance, UINT16 mode, INT16 argc, char **argn,
char **argv, NPSavedData *saved)
{
HTMLPluginContainer *container;
nsIDOMHTMLElement *nselem;
HTMLInnerWindow *window;
IUnknown *obj;
CLSID clsid;
HTMLDOMNode *node;
NPError err = NPERR_NO_ERROR;
HRESULT hres;
TRACE("(%s %p %x %d %p %p %p)\n", debugstr_a(pluginType), instance, mode, argc, argn, argv, saved);
@ -643,22 +272,30 @@ static NPError CDECL NPP_New(NPMIMEType pluginType, NPP instance, UINT16 mode, I
return NPERR_GENERIC_ERROR;
}
obj = create_activex_object(window, nselem, &clsid);
if(obj) {
PluginHost *host;
HRESULT hres;
hres = get_node(window->doc, (nsIDOMNode*)nselem, TRUE, &node);
nsIDOMHTMLElement_Release(nselem);
if(FAILED(hres))
return NPERR_GENERIC_ERROR;
hres = create_plugin_host(window->doc, (nsIDOMElement*)nselem, obj, &clsid, &host);
IUnknown_Release(obj);
if(SUCCEEDED(hres))
instance->pdata = host;
else
err = NPERR_GENERIC_ERROR;
}else {
err = NPERR_GENERIC_ERROR;
hres = IHTMLDOMNode_QueryInterface(&node->IHTMLDOMNode_iface, &IID_HTMLPluginContainer,
(void**)&container);
node_release(node);
if(FAILED(hres)) {
ERR("Not an object element\n");
return NPERR_GENERIC_ERROR;
}
nsIDOMHTMLElement_Release(nselem);
if(!container->plugin_host) {
hres = create_plugin_host(window->doc, container);
if(FAILED(hres))
err = NPERR_GENERIC_ERROR;
}else {
TRACE("plugin host already associated.\n");
}
instance->pdata = container->plugin_host;
node_release(&container->element.node);
return err;
}

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

@ -512,7 +512,6 @@ static BOOL load_xul(const PRUnichar *gre_path)
NS_DLSYM(ccref_incr);
NS_DLSYM(ccref_decr);
NS_DLSYM(ccref_init);
NS_DLSYM(ccref_unmark_if_purple);
NS_DLSYM(ccp_init);
NS_DLSYM(describe_cc_node);
NS_DLSYM(note_cc_edge);
@ -1139,6 +1138,28 @@ BOOL is_gecko_path(const char *path)
return ret;
}
void set_viewer_zoom(NSContainer *nscontainer, float factor)
{
nsIContentViewer *content_viewer;
nsIDocShell *doc_shell;
nsresult nsres;
TRACE("Setting to %f\n", factor);
nsres = get_nsinterface((nsISupports*)nscontainer->navigation, &IID_nsIDocShell, (void**)&doc_shell);
assert(nsres == NS_OK);
nsres = nsIDocShell_GetContentViewer(doc_shell, &content_viewer);
assert(nsres == NS_OK && content_viewer);
nsIDocShell_Release(doc_shell);
nsres = nsIContentViewer_SetFullZoom(content_viewer, factor);
if(NS_FAILED(nsres))
ERR("SetFullZoom failed: %08x\n", nsres);
nsIContentViewer_Release(content_viewer);
}
struct nsWeakReference {
nsIWeakReference nsIWeakReference_iface;
@ -1702,8 +1723,24 @@ static nsresult NSAPI nsEmbeddingSiteWindow_GetDimensions(nsIEmbeddingSiteWindow
UINT32 flags, LONG *x, LONG *y, LONG *cx, LONG *cy)
{
NSContainer *This = impl_from_nsIEmbeddingSiteWindow(iface);
WARN("(%p)->(%08x %p %p %p %p)\n", This, flags, x, y, cx, cy);
return NS_ERROR_NOT_IMPLEMENTED;
RECT r;
TRACE("(%p)->(%x %p %p %p %p)\n", This, flags, x, y, cx, cy);
if(!GetWindowRect(This->hwnd, &r)) {
ERR("GetWindowRect failed\n");
return NS_ERROR_FAILURE;
}
if(x)
*x = r.left;
if(y)
*y = r.top;
if(cx)
*cx = r.right-r.left;
if(cy)
*cy = r.bottom-r.top;
return NS_OK;
}
static nsresult NSAPI nsEmbeddingSiteWindow_SetFocus(nsIEmbeddingSiteWindow *iface)

9
reactos/dll/win32/mshtml/nsevents.c
View file

@ -212,7 +212,6 @@ static nsresult NSAPI handle_load(nsIDOMEventListener *iface, nsIDOMEvent *event
{
nsEventListener *This = impl_from_nsIDOMEventListener(iface);
HTMLDocumentNode *doc = This->This->doc;
nsIDOMHTMLElement *nsbody = NULL;
HTMLDocumentObj *doc_obj = NULL;
nsresult nsres = NS_OK;
@ -247,8 +246,12 @@ static nsresult NSAPI handle_load(nsIDOMEventListener *iface, nsIDOMEvent *event
&doc->basedoc.window->base.IHTMLWindow2_iface, 0);
if(doc->nsdoc) {
nsIDOMHTMLDocument_GetBody(doc->nsdoc, &nsbody);
if(nsbody) {
nsIDOMHTMLElement *nsbody;
flush_pending_tasks(doc->basedoc.task_magic);
nsres = nsIDOMHTMLDocument_GetBody(doc->nsdoc, &nsbody);
if(NS_SUCCEEDED(nsres) && nsbody) {
fire_event(doc, EVENTID_LOAD, TRUE, (nsIDOMNode*)nsbody, event, (IDispatch*)&doc->window->base.IDispatchEx_iface);
nsIDOMHTMLElement_Release(nsbody);
}

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

File diff suppressed because it is too large Load diff

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

@ -247,8 +247,10 @@ static nsresult before_async_open(nsChannel *channel, NSContainer *container, BO
return NS_OK;
}
HRESULT load_nsuri(HTMLOuterWindow *window, nsWineURI *uri, nsChannelBSC *channelbsc, DWORD flags)
HRESULT load_nsuri(HTMLOuterWindow *window, nsWineURI *uri, nsIInputStream *post_stream,
nsChannelBSC *channelbsc, DWORD flags)
{
nsIDocShellLoadInfo *load_info = NULL;
nsIWebNavigation *web_navigation;
nsIDocShell *doc_shell;
HTMLDocumentNode *doc;
@ -267,14 +269,27 @@ HRESULT load_nsuri(HTMLOuterWindow *window, nsWineURI *uri, nsChannelBSC *channe
return E_FAIL;
}
if(post_stream) {
nsres = nsIDocShell_CreateLoadInfo(doc_shell, &load_info);
if(NS_FAILED(nsres)) {
nsIDocShell_Release(doc_shell);
return E_FAIL;
}
nsres = nsIDocShellLoadInfo_SetPostDataStream(load_info, post_stream);
assert(nsres == NS_OK);
}
uri->channel_bsc = channelbsc;
doc = window->base.inner_window->doc;
doc->skip_mutation_notif = TRUE;
nsres = nsIDocShell_LoadURI(doc_shell, (nsIURI*)&uri->nsIFileURL_iface, NULL, flags, FALSE);
nsres = nsIDocShell_LoadURI(doc_shell, (nsIURI*)&uri->nsIFileURL_iface, load_info, flags, FALSE);
if(doc == window->base.inner_window->doc)
doc->skip_mutation_notif = FALSE;
uri->channel_bsc = NULL;
nsIDocShell_Release(doc_shell);
if(load_info)
nsIDocShellLoadInfo_Release(load_info);
if(NS_FAILED(nsres)) {
WARN("LoadURI failed: %08x\n", nsres);
return E_FAIL;
@ -1158,6 +1173,32 @@ static nsresult NSAPI nsChannel_GetContentDispositionHeader(nsIHttpChannel *ifac
return NS_ERROR_NOT_IMPLEMENTED;
}
static nsresult NSAPI nsChannel_GetLoadInfo(nsIHttpChannel *iface, nsILoadInfo **aLoadInfo)
{
nsChannel *This = impl_from_nsIHttpChannel(iface);
TRACE("(%p)->(%p)\n", This, aLoadInfo);
if(This->load_info)
nsISupports_AddRef(This->load_info);
*aLoadInfo = This->load_info;
return NS_OK;
}
static nsresult NSAPI nsChannel_SetLoadInfo(nsIHttpChannel *iface, nsILoadInfo *aLoadInfo)
{
nsChannel *This = impl_from_nsIHttpChannel(iface);
TRACE("(%p)->(%p)\n", This, aLoadInfo);
if(This->load_info)
nsISupports_Release(This->load_info);
This->load_info = aLoadInfo;
if(This->load_info)
nsISupports_AddRef(This->load_info);
return NS_OK;
}
static nsresult NSAPI nsChannel_GetRequestMethod(nsIHttpChannel *iface, nsACString *aRequestMethod)
{
nsChannel *This = impl_from_nsIHttpChannel(iface);
@ -1266,6 +1307,20 @@ static nsresult NSAPI nsChannel_SetAllowPipelining(nsIHttpChannel *iface, cpp_bo
return NS_ERROR_NOT_IMPLEMENTED;
}
static nsresult NSAPI nsChannel_GetAllowTLS(nsIHttpChannel *iface, cpp_bool *aAllowTLS)
{
nsChannel *This = impl_from_nsIHttpChannel(iface);
FIXME("(%p)->(%p)\n", This, aAllowTLS);
return NS_ERROR_NOT_IMPLEMENTED;
}
static nsresult NSAPI nsChannel_SetAllowTLS(nsIHttpChannel *iface, cpp_bool aAllowTLS)
{
nsChannel *This = impl_from_nsIHttpChannel(iface);
FIXME("(%p)->(%x)\n", This, aAllowTLS);
return NS_ERROR_NOT_IMPLEMENTED;
}
static nsresult NSAPI nsChannel_GetRedirectionLimit(nsIHttpChannel *iface, UINT32 *aRedirectionLimit)
{
nsChannel *This = impl_from_nsIHttpChannel(iface);
@ -1422,6 +1477,8 @@ static const nsIHttpChannelVtbl nsChannelVtbl = {
nsChannel_GetContentDispositionFilename,
nsChannel_SetContentDispositionFilename,
nsChannel_GetContentDispositionHeader,
nsChannel_GetLoadInfo,
nsChannel_SetLoadInfo,
nsChannel_GetRequestMethod,
nsChannel_SetRequestMethod,
nsChannel_GetReferrer,
@ -1431,6 +1488,8 @@ static const nsIHttpChannelVtbl nsChannelVtbl = {
nsChannel_VisitRequestHeaders,
nsChannel_GetAllowPipelining,
nsChannel_SetAllowPipelining,
nsChannel_GetAllowTLS,
nsChannel_SetAllowTLS,
nsChannel_GetRedirectionLimit,
nsChannel_SetRedirectionLimit,
nsChannel_GetResponseStatus,
@ -1592,6 +1651,15 @@ static nsresult NSAPI nsHttpChannelInternal_GetResponseVersion(nsIHttpChannelInt
return NS_ERROR_NOT_IMPLEMENTED;
}
static nsresult NSAPI nsHttpChannelInternal_TakeAllSecurityMessages(nsIHttpChannelInternal *iface, void *aMessages)
{
nsChannel *This = impl_from_nsIHttpChannelInternal(iface);
FIXME("(%p)->()\n", This);
return NS_ERROR_NOT_IMPLEMENTED;
}
static nsresult NSAPI nsHttpChannelInternal_SetCookie(nsIHttpChannelInternal *iface, const char *aCookieHeader)
{
nsChannel *This = impl_from_nsIHttpChannelInternal(iface);
@ -1750,6 +1818,43 @@ static nsresult NSAPI nsHttpChannelInternal_SetLoadUnblocked(nsIHttpChannelInter
return NS_ERROR_NOT_IMPLEMENTED;
}
static nsresult NSAPI nsHttpChannelInternal_GetResponseTimeoutEnabled(nsIHttpChannelInternal *iface,
cpp_bool *aResponseTimeoutEnabled)
{
nsChannel *This = impl_from_nsIHttpChannelInternal(iface);
FIXME("(%p)->(%p)\n", This, aResponseTimeoutEnabled);
return NS_ERROR_NOT_IMPLEMENTED;
}
static nsresult NSAPI nsHttpChannelInternal_SetResponseTimeoutEnabled(nsIHttpChannelInternal *iface,
cpp_bool aResponseTimeoutEnabled)
{
nsChannel *This = impl_from_nsIHttpChannelInternal(iface);
FIXME("(%p)->(%x)\n", This, aResponseTimeoutEnabled);
return NS_ERROR_NOT_IMPLEMENTED;
}
static nsresult NSAPI nsHttpChannelInternal_GetApiRedirectToURI(nsIHttpChannelInternal *iface, nsIURI **aApiRedirectToURI)
{
nsChannel *This = impl_from_nsIHttpChannelInternal(iface);
FIXME("(%p)->(%p)\n", This, aApiRedirectToURI);
return NS_ERROR_NOT_IMPLEMENTED;
}
static nsresult NSAPI nsHttpChannelInternal_AddRedirect(nsIHttpChannelInternal *iface, nsIPrincipal *aPrincipal)
{
nsChannel *This = impl_from_nsIHttpChannelInternal(iface);
FIXME("(%p)->(%p)\n", This, aPrincipal);
return NS_ERROR_NOT_IMPLEMENTED;
}
static nsresult NSAPI nsHttpChannelInternal_GetLastModifiedTime(nsIHttpChannelInternal *iface, PRTime *aLastModifiedTime)
{
nsChannel *This = impl_from_nsIHttpChannelInternal(iface);
FIXME("(%p)->(%p)\n", This, aLastModifiedTime);
return NS_ERROR_NOT_IMPLEMENTED;
}
static const nsIHttpChannelInternalVtbl nsHttpChannelInternalVtbl = {
nsHttpChannelInternal_QueryInterface,
nsHttpChannelInternal_AddRef,
@ -1758,6 +1863,7 @@ static const nsIHttpChannelInternalVtbl nsHttpChannelInternalVtbl = {
nsHttpChannelInternal_SetDocumentURI,
nsHttpChannelInternal_GetRequestVersion,
nsHttpChannelInternal_GetResponseVersion,
nsHttpChannelInternal_TakeAllSecurityMessages,
nsHttpChannelInternal_SetCookie,
nsHttpChannelInternal_SetupFallbackChannel,
nsHttpChannelInternal_GetForceAllowThirdPartyCookie,
@ -1776,7 +1882,12 @@ static const nsIHttpChannelInternalVtbl nsHttpChannelInternalVtbl = {
nsHttpChannelInternal_GetLoadAsBlocking,
nsHttpChannelInternal_SetLoadAsBlocking,
nsHttpChannelInternal_GetLoadUnblocked,
nsHttpChannelInternal_SetLoadUnblocked
nsHttpChannelInternal_SetLoadUnblocked,
nsHttpChannelInternal_GetResponseTimeoutEnabled,
nsHttpChannelInternal_SetResponseTimeoutEnabled,
nsHttpChannelInternal_GetApiRedirectToURI,
nsHttpChannelInternal_AddRedirect,
nsHttpChannelInternal_GetLastModifiedTime
};
@ -1959,8 +2070,42 @@ static nsresult NSAPI nsURI_SetSpec(nsIFileURL *iface, const nsACString *aSpec)
static nsresult NSAPI nsURI_GetPrePath(nsIFileURL *iface, nsACString *aPrePath)
{
nsWineURI *This = impl_from_nsIFileURL(iface);
FIXME("(%p)->(%p)\n", This, aPrePath);
return NS_ERROR_NOT_IMPLEMENTED;
IUriBuilder *uri_builder;
BSTR display_uri;
IUri *uri;
int len;
nsresult nsres;
HRESULT hres;
TRACE("(%p)->(%p)\n", This, aPrePath);
if(!ensure_uri(This))
return NS_ERROR_UNEXPECTED;
hres = CreateIUriBuilder(This->uri, 0, 0, &uri_builder);
if(FAILED(hres))
return NS_ERROR_FAILURE;
hres = IUriBuilder_RemoveProperties(uri_builder, Uri_HAS_PATH|Uri_HAS_QUERY|Uri_HAS_FRAGMENT);
if(SUCCEEDED(hres))
hres = IUriBuilder_CreateUriSimple(uri_builder, 0, 0, &uri);
IUriBuilder_Release(uri_builder);
if(FAILED(hres))
return NS_ERROR_FAILURE;
hres = IUri_GetDisplayUri(uri, &display_uri);
IUri_Release(uri);
if(FAILED(hres))
return NS_ERROR_FAILURE;
/* Remove trailing slash that may be appended as default path. */
len = SysStringLen(display_uri);
if(len && display_uri[len-1] == '/')
display_uri[len-1] = 0;
nsres = return_wstr_nsacstr(aPrePath, display_uri, -1);
SysFreeString(display_uri);
return nsres;
}
static nsresult NSAPI nsURI_GetScheme(nsIFileURL *iface, nsACString *aScheme)
@ -3296,6 +3441,7 @@ static nsresult NSAPI nsIOService_NewURI(nsIIOService *iface, const nsACString *
WCHAR new_spec[INTERNET_MAX_URL_LENGTH];
HTMLOuterWindow *window = NULL;
const char *spec = NULL;
UINT cp = CP_UTF8;
IUri *urlmon_uri;
nsresult nsres;
HRESULT hres;
@ -3322,7 +3468,22 @@ static nsresult NSAPI nsIOService_NewURI(nsIIOService *iface, const nsACString *
}
}
MultiByteToWideChar(CP_ACP, 0, spec, -1, new_spec, sizeof(new_spec)/sizeof(WCHAR));
if(aOriginCharset && *aOriginCharset && strncasecmp(aOriginCharset, "utf", 3)) {
BSTR charset;
int len;
len = MultiByteToWideChar(CP_UTF8, 0, aOriginCharset, -1, NULL, 0);
charset = SysAllocStringLen(NULL, len-1);
if(!charset)
return NS_ERROR_OUT_OF_MEMORY;
MultiByteToWideChar(CP_UTF8, 0, aOriginCharset, -1, charset, len);
cp = cp_from_charset_string(charset);
SysFreeString(charset);
}
MultiByteToWideChar(cp, 0, spec, -1, new_spec, sizeof(new_spec)/sizeof(WCHAR));
if(base_wine_uri) {
hres = combine_url(base_wine_uri->uri, new_spec, &urlmon_uri);
@ -3455,18 +3616,48 @@ static nsresult NSAPI nsNetUtil_ParseContentType(nsINetUtil *iface, const nsACSt
return nsINetUtil_ParseContentType(net_util, aTypeHeader, aCharset, aHadCharset, aContentType);
}
static const char *debugstr_protocol_flags(UINT32 flags)
{
switch(flags) {
#define X(f) case f: return #f
X(URI_STD);
X(URI_NORELATIVE);
X(URI_NOAUTH);
X(ALLOWS_PROXY);
X(ALLOWS_PROXY_HTTP);
X(URI_INHERITS_SECURITY_CONTEXT);
X(URI_FORBIDS_AUTOMATIC_DOCUMENT_REPLACEMENT);
X(URI_LOADABLE_BY_ANYONE);
X(URI_DANGEROUS_TO_LOAD);
X(URI_IS_UI_RESOURCE);
X(URI_IS_LOCAL_FILE);
X(URI_LOADABLE_BY_SUBSUMERS);
X(URI_DOES_NOT_RETURN_DATA);
X(URI_IS_LOCAL_RESOURCE);
X(URI_OPENING_EXECUTES_SCRIPT);
X(URI_NON_PERSISTABLE);
X(URI_FORBIDS_COOKIE_ACCESS);
X(URI_CROSS_ORIGIN_NEEDS_WEBAPPS_PERM);
X(URI_SYNC_LOAD_IS_OK);
X(URI_SAFE_TO_LOAD_IN_SECURE_CONTEXT);
#undef X
default:
return wine_dbg_sprintf("%08x", flags);
}
}
static nsresult NSAPI nsNetUtil_ProtocolHasFlags(nsINetUtil *iface, nsIURI *aURI, UINT32 aFlags, cpp_bool *_retval)
{
TRACE("()\n");
TRACE("(%p %s %p)\n", aURI, debugstr_protocol_flags(aFlags), _retval);
return nsINetUtil_ProtocolHasFlags(net_util, aURI, aFlags, _retval);
}
static nsresult NSAPI nsNetUtil_URIChainHasFlags(nsINetUtil *iface, nsIURI *aURI, UINT32 aFlags, cpp_bool *_retval)
{
TRACE("(%p %08x %p)\n", aURI, aFlags, _retval);
TRACE("(%p %s %p)\n", aURI, debugstr_protocol_flags(aFlags), _retval);
if(aFlags == (1<<11)) {
if(aFlags == URI_DOES_NOT_RETURN_DATA) {
*_retval = FALSE;
return NS_OK;
}

125
reactos/dll/win32/mshtml/olecmd.c
View file

@ -43,6 +43,28 @@ void do_ns_command(HTMLDocument *This, const char *cmd, nsICommandParams *nspara
nsICommandManager_Release(cmdmgr);
}
static nsIClipboardCommands *get_clipboard_commands(HTMLDocument *doc)
{
nsIClipboardCommands *clipboard_commands;
nsIDocShell *doc_shell;
nsresult nsres;
nsres = get_nsinterface((nsISupports*)doc->window->nswindow, &IID_nsIDocShell, (void**)&doc_shell);
if(NS_FAILED(nsres)) {
ERR("Could not get nsIDocShell interface\n");
return NULL;
}
nsres = nsIDocShell_QueryInterface(doc_shell, &IID_nsIClipboardCommands, (void**)&clipboard_commands);
nsIDocShell_Release(doc_shell);
if(NS_FAILED(nsres)) {
ERR("Could not get nsIClipboardCommands interface\n");
return NULL;
}
return clipboard_commands;
}
/**********************************************************
* IOleCommandTarget implementation
*/
@ -505,6 +527,19 @@ static HRESULT exec_get_print_template(HTMLDocument *This, DWORD nCmdexecopt, VA
return E_NOTIMPL;
}
static HRESULT exec_optical_zoom(HTMLDocument *This, DWORD nCmdexecopt, VARIANT *pvaIn, VARIANT *pvaOut)
{
TRACE("(%p)->(%d %s %p)\n", This, nCmdexecopt, debugstr_variant(pvaIn), pvaOut);
if(!pvaIn || V_VT(pvaIn) != VT_I4) {
FIXME("Unsupported argument %s\n", debugstr_variant(pvaIn));
return E_NOTIMPL;
}
set_viewer_zoom(This->doc_obj->nscontainer, (float)V_I4(pvaIn)/100);
return S_OK;
}
static HRESULT query_mshtml_copy(HTMLDocument *This, OLECMD *cmd)
{
FIXME("(%p)\n", This);
@ -532,13 +567,26 @@ static HRESULT query_mshtml_cut(HTMLDocument *This, OLECMD *cmd)
static HRESULT exec_mshtml_cut(HTMLDocument *This, DWORD cmdexecopt, VARIANT *in, VARIANT *out)
{
nsIClipboardCommands *clipboard_commands;
nsresult nsres;
TRACE("(%p)->(%08x %p %p)\n", This, cmdexecopt, in, out);
if(This->doc_obj->usermode == EDITMODE)
return editor_exec_cut(This, cmdexecopt, in, out);
FIXME("Unimplemented in browse mode\n");
return E_NOTIMPL;
clipboard_commands = get_clipboard_commands(This);
if(!clipboard_commands)
return E_UNEXPECTED;
nsres = nsIClipboardCommands_CutSelection(clipboard_commands);
nsIClipboardCommands_Release(clipboard_commands);
if(NS_FAILED(nsres)) {
ERR("Paste failed: %08x\n", nsres);
return E_FAIL;
}
return S_OK;
}
static HRESULT query_mshtml_paste(HTMLDocument *This, OLECMD *cmd)
@ -550,13 +598,26 @@ static HRESULT query_mshtml_paste(HTMLDocument *This, OLECMD *cmd)
static HRESULT exec_mshtml_paste(HTMLDocument *This, DWORD cmdexecopt, VARIANT *in, VARIANT *out)
{
nsIClipboardCommands *clipboard_commands;
nsresult nsres;
TRACE("(%p)->(%08x %p %p)\n", This, cmdexecopt, in, out);
if(This->doc_obj->usermode == EDITMODE)
return editor_exec_paste(This, cmdexecopt, in, out);
FIXME("Unimplemented in browse mode\n");
return E_NOTIMPL;
clipboard_commands = get_clipboard_commands(This);
if(!clipboard_commands)
return E_UNEXPECTED;
nsres = nsIClipboardCommands_Paste(clipboard_commands);
nsIClipboardCommands_Release(clipboard_commands);
if(NS_FAILED(nsres)) {
ERR("Paste failed: %08x\n", nsres);
return E_FAIL;
}
return S_OK;
}
static HRESULT exec_browsemode(HTMLDocument *This, DWORD cmdexecopt, VARIANT *in, VARIANT *out)
@ -596,8 +657,13 @@ static HRESULT exec_baselinefont3(HTMLDocument *This, DWORD cmdexecopt, VARIANT
static HRESULT exec_respectvisibility_indesign(HTMLDocument *This, DWORD cmdexecopt,
VARIANT *in, VARIANT *out)
{
FIXME("(%p)->(%08x %p %p)\n", This, cmdexecopt, in, out);
return E_NOTIMPL;
TRACE("(%p)->(%x %s %p)\n", This, cmdexecopt, debugstr_variant(in), out);
/* This is turned on by default in Gecko. */
if(!in || V_VT(in) != VT_BOOL || !V_BOOL(in))
FIXME("Unsupported argument %s\n", debugstr_variant(in));
return S_OK;
}
static HRESULT query_enabled_stub(HTMLDocument *This, OLECMD *cmd)
@ -623,7 +689,7 @@ static HRESULT query_enabled_stub(HTMLDocument *This, OLECMD *cmd)
static const struct {
OLECMDF cmdf;
HRESULT (*func)(HTMLDocument*,DWORD,VARIANT*,VARIANT*);
} exec_table[OLECMDID_GETPRINTTEMPLATE+1] = {
} exec_table[] = {
{0},
{ OLECMDF_SUPPORTED, exec_open }, /* OLECMDID_OPEN */
{ OLECMDF_SUPPORTED, exec_new }, /* OLECMDID_NEW */
@ -663,7 +729,9 @@ static const struct {
{ OLECMDF_SUPPORTED, exec_close }, /* OLECMDID_CLOSE */
{0},{0},{0},
{ OLECMDF_SUPPORTED, exec_set_print_template }, /* OLECMDID_SETPRINTTEMPLATE */
{ OLECMDF_SUPPORTED, exec_get_print_template } /* OLECMDID_GETPRINTTEMPLATE */
{ OLECMDF_SUPPORTED, exec_get_print_template }, /* OLECMDID_GETPRINTTEMPLATE */
{0},{0},{0},{0},{0},{0},{0},{0},{0},{0},
{ 0, /* not reported as supported */ exec_optical_zoom } /* OLECMDID_OPTICAL_ZOOM */
};
static const cmdtable_t base_cmds[] = {
@ -718,18 +786,22 @@ static HRESULT WINAPI OleCommandTarget_QueryStatus(IOleCommandTarget *iface, con
ULONG cCmds, OLECMD prgCmds[], OLECMDTEXT *pCmdText)
{
HTMLDocument *This = impl_from_IOleCommandTarget(iface);
HRESULT hres = S_OK, hr;
HRESULT hres;
TRACE("(%p)->(%s %d %p %p)\n", This, debugstr_guid(pguidCmdGroup), cCmds, prgCmds, pCmdText);
if(pCmdText)
FIXME("Unsupported pCmdText\n");
if(!cCmds)
return S_OK;
if(!pguidCmdGroup) {
ULONG i;
for(i=0; i<cCmds; i++) {
if(prgCmds[i].cmdID<OLECMDID_OPEN || prgCmds[i].cmdID>OLECMDID_GETPRINTTEMPLATE) {
if(prgCmds[i].cmdID < OLECMDID_OPEN || prgCmds[i].cmdID >= sizeof(exec_table)/sizeof(*exec_table)) {
WARN("Unsupported cmdID = %d\n", prgCmds[i].cmdID);
prgCmds[i].cmdf = 0;
hres = OLECMDERR_E_NOTSUPPORTED;
}else {
if(prgCmds[i].cmdID == OLECMDID_OPEN || prgCmds[i].cmdID == OLECMDID_NEW) {
IOleCommandTarget *cmdtrg = NULL;
@ -737,14 +809,14 @@ static HRESULT WINAPI OleCommandTarget_QueryStatus(IOleCommandTarget *iface, con
prgCmds[i].cmdf = OLECMDF_SUPPORTED;
if(This->doc_obj->client) {
hr = IOleClientSite_QueryInterface(This->doc_obj->client, &IID_IOleCommandTarget,
hres = IOleClientSite_QueryInterface(This->doc_obj->client, &IID_IOleCommandTarget,
(void**)&cmdtrg);
if(SUCCEEDED(hr)) {
if(SUCCEEDED(hres)) {
olecmd.cmdID = prgCmds[i].cmdID;
olecmd.cmdf = 0;
hr = IOleCommandTarget_QueryStatus(cmdtrg, NULL, 1, &olecmd, NULL);
if(SUCCEEDED(hr) && olecmd.cmdf)
hres = IOleCommandTarget_QueryStatus(cmdtrg, NULL, 1, &olecmd, NULL);
if(SUCCEEDED(hres) && olecmd.cmdf)
prgCmds[i].cmdf = olecmd.cmdf;
}
}else {
@ -754,33 +826,28 @@ static HRESULT WINAPI OleCommandTarget_QueryStatus(IOleCommandTarget *iface, con
prgCmds[i].cmdf = exec_table[prgCmds[i].cmdID].cmdf;
TRACE("cmdID = %d returning %x\n", prgCmds[i].cmdID, prgCmds[i].cmdf);
}
hres = S_OK;
}
}
if(pCmdText)
FIXME("Set pCmdText\n");
}else if(IsEqualGUID(&CGID_MSHTML, pguidCmdGroup)) {
return (prgCmds[cCmds-1].cmdf & OLECMDF_SUPPORTED) ? S_OK : OLECMDERR_E_NOTSUPPORTED;
}
if(IsEqualGUID(&CGID_MSHTML, pguidCmdGroup)) {
ULONG i;
for(i=0; i<cCmds; i++) {
HRESULT hres = query_from_table(This, base_cmds, prgCmds+i);
hres = query_from_table(This, base_cmds, prgCmds+i);
if(hres == OLECMDERR_E_NOTSUPPORTED)
hres = query_from_table(This, editmode_cmds, prgCmds+i);
if(hres == OLECMDERR_E_NOTSUPPORTED)
FIXME("CGID_MSHTML: unsupported cmdID %d\n", prgCmds[i].cmdID);
}
hres = prgCmds[i-1].cmdf ? S_OK : OLECMDERR_E_NOTSUPPORTED;
if(pCmdText)
FIXME("Set pCmdText\n");
}else {
FIXME("Unsupported pguidCmdGroup %s\n", debugstr_guid(pguidCmdGroup));
hres = OLECMDERR_E_UNKNOWNGROUP;
return (prgCmds[cCmds-1].cmdf & OLECMDF_SUPPORTED) ? S_OK : OLECMDERR_E_NOTSUPPORTED;
}
return hres;
FIXME("Unsupported pguidCmdGroup %s\n", debugstr_guid(pguidCmdGroup));
return OLECMDERR_E_UNKNOWNGROUP;
}
static HRESULT exec_from_table(HTMLDocument *This, const cmdtable_t *cmdtable, DWORD cmdid,
@ -803,7 +870,7 @@ static HRESULT WINAPI OleCommandTarget_Exec(IOleCommandTarget *iface, const GUID
HTMLDocument *This = impl_from_IOleCommandTarget(iface);
if(!pguidCmdGroup) {
if(nCmdID<OLECMDID_OPEN || nCmdID>OLECMDID_GETPRINTTEMPLATE || !exec_table[nCmdID].func) {
if(nCmdID < OLECMDID_OPEN || nCmdID >= sizeof(exec_table)/sizeof(*exec_table) || !exec_table[nCmdID].func) {
WARN("Unsupported cmdID = %d\n", nCmdID);
return OLECMDERR_E_NOTSUPPORTED;
}

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

@ -208,13 +208,9 @@ void set_document_navigation(HTMLDocumentObj *doc, BOOL doc_can_navigate)
static void load_settings(HTMLDocumentObj *doc)
{
nsIMarkupDocumentViewer *markup_document_viewer;
nsIContentViewer *content_viewer;
nsIDocShell *doc_shell;
HKEY settings_key;
DWORD val, size;
LONG res;
nsresult nsres;
static const WCHAR ie_keyW[] = {
'S','O','F','T','W','A','R','E','\\',
@ -230,26 +226,8 @@ static void load_settings(HTMLDocumentObj *doc)
size = sizeof(val);
res = RegGetValueW(settings_key, zoomW, zoom_factorW, RRF_RT_REG_DWORD, NULL, &val, &size);
RegCloseKey(settings_key);
if(res != ERROR_SUCCESS)
return;
TRACE("Setting ZoomFactor to %u\n", val);
nsres = get_nsinterface((nsISupports*)doc->nscontainer->navigation, &IID_nsIDocShell, (void**)&doc_shell);
assert(nsres == NS_OK);
nsres = nsIDocShell_GetContentViewer(doc_shell, &content_viewer);
assert(nsres == NS_OK && content_viewer);
nsres = nsISupports_QueryInterface(content_viewer, &IID_nsIMarkupDocumentViewer, (void**)&markup_document_viewer);
nsISupports_Release(content_viewer);
assert(nsres == NS_OK);
nsres = nsIMarkupDocumentViewer_SetFullZoom(markup_document_viewer, (float)val/100000);
if(NS_FAILED(nsres))
ERR("SetFullZoom failed: %08x\n", nsres);
nsIDocShell_Release(doc_shell);
if(res == ERROR_SUCCESS)
set_viewer_zoom(doc->nscontainer, (float)val/100000);
}
static HRESULT WINAPI OleObject_SetClientSite(IOleObject *iface, IOleClientSite *pClientSite)

46
reactos/dll/win32/mshtml/omnavigator.c
View file

@ -192,25 +192,22 @@ static HRESULT WINAPI OmHistory_QueryInterface(IOmHistory *iface, REFIID riid, v
{
OmHistory *This = impl_from_IOmHistory(iface);
*ppv = NULL;
TRACE("(%p)->(%s %p)\n", This, debugstr_mshtml_guid(riid), ppv);
if(IsEqualGUID(&IID_IUnknown, riid)) {
TRACE("(%p)->(IID_IUnknown %p)\n", This, ppv);
*ppv = &This->IOmHistory_iface;
}else if(IsEqualGUID(&IID_IOmHistory, riid)) {
TRACE("(%p)->(IID_IOmHistory %p)\n", This, ppv);
*ppv = &This->IOmHistory_iface;
}else if(dispex_query_interface(&This->dispex, riid, ppv)) {
return *ppv ? S_OK : E_NOINTERFACE;
}else {
WARN("Unsupported interface %s\n", debugstr_mshtml_guid(riid));
*ppv = NULL;
return E_NOINTERFACE;
}
if(*ppv) {
IUnknown_AddRef((IUnknown*)*ppv);
return S_OK;
}
WARN("(%p)->(%s %p)\n", This, debugstr_guid(riid), ppv);
return E_NOINTERFACE;
IUnknown_AddRef((IUnknown*)*ppv);
return S_OK;
}
static ULONG WINAPI OmHistory_AddRef(IOmHistory *iface)
@ -370,17 +367,17 @@ static HRESULT WINAPI HTMLPluginsCollection_QueryInterface(IHTMLPluginsCollectio
{
HTMLPluginsCollection *This = impl_from_IHTMLPluginsCollection(iface);
TRACE("(%p)->(%s %p)\n", This, debugstr_mshtml_guid(riid), ppv);
if(IsEqualGUID(&IID_IUnknown, riid)) {
TRACE("(%p)->(IID_IUnknown %p)\n", This, ppv);
*ppv = &This->IHTMLPluginsCollection_iface;
}else if(IsEqualGUID(&IID_IHTMLPluginsCollection, riid)) {
TRACE("(%p)->(IID_IHTMLPluginCollection %p)\n", This, ppv);
*ppv = &This->IHTMLPluginsCollection_iface;
}else if(dispex_query_interface(&This->dispex, riid, ppv)) {
return *ppv ? S_OK : E_NOINTERFACE;
}else {
*ppv = NULL;
WARN("(%p)->(%s %p)\n", This, debugstr_guid(riid), ppv);
WARN("Unsupported interface %s\n", debugstr_mshtml_guid(riid));
return E_NOINTERFACE;
}
@ -523,17 +520,17 @@ static HRESULT WINAPI HTMLMimeTypesCollection_QueryInterface(IHTMLMimeTypesColle
{
HTMLMimeTypesCollection *This = impl_from_IHTMLMimeTypesCollection(iface);
TRACE("(%p)->(%s %p)\n", This, debugstr_mshtml_guid(riid), ppv);
if(IsEqualGUID(&IID_IUnknown, riid)) {
TRACE("(%p)->(IID_IUnknown %p)\n", This, ppv);
*ppv = &This->IHTMLMimeTypesCollection_iface;
}else if(IsEqualGUID(&IID_IHTMLMimeTypesCollection, riid)) {
TRACE("(%p)->(IID_IHTMLMimeTypesCollection %p)\n", This, ppv);
*ppv = &This->IHTMLMimeTypesCollection_iface;
}else if(dispex_query_interface(&This->dispex, riid, ppv)) {
return *ppv ? S_OK : E_NOINTERFACE;
}else {
WARN("Unsupported interface %s\n", debugstr_mshtml_guid(riid));
*ppv = NULL;
WARN("(%p)->(%s %p)\n", This, debugstr_guid(riid), ppv);
return E_NOINTERFACE;
}
@ -659,25 +656,22 @@ static HRESULT WINAPI OmNavigator_QueryInterface(IOmNavigator *iface, REFIID rii
{
OmNavigator *This = impl_from_IOmNavigator(iface);
*ppv = NULL;
TRACE("(%p)->(%s %p)\n", This, debugstr_mshtml_guid(riid), ppv);
if(IsEqualGUID(&IID_IUnknown, riid)) {
TRACE("(%p)->(IID_IUnknown %p)\n", This, ppv);
*ppv = &This->IOmNavigator_iface;
}else if(IsEqualGUID(&IID_IOmNavigator, riid)) {
TRACE("(%p)->(IID_IOmNavigator %p)\n", This, ppv);
*ppv = &This->IOmNavigator_iface;
}else if(dispex_query_interface(&This->dispex, riid, ppv)) {
return *ppv ? S_OK : E_NOINTERFACE;
}else {
WARN("Unsupported interface %s\n", debugstr_mshtml_guid(riid));
*ppv = NULL;
return E_NOINTERFACE;
}
if(*ppv) {
IUnknown_AddRef((IUnknown*)*ppv);
return S_OK;
}
WARN("(%p)->(%s %p)\n", This, debugstr_guid(riid), ppv);
return E_NOINTERFACE;
IUnknown_AddRef((IUnknown*)*ppv);
return S_OK;
}
static ULONG WINAPI OmNavigator_AddRef(IOmNavigator *iface)

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

@ -371,7 +371,7 @@ HRESULT set_moniker(HTMLOuterWindow *window, IMoniker *mon, IUri *nav_uri, IBind
remove_target_tasks(window->base.inner_window->task_magic);
abort_window_bindings(window->base.inner_window);
hres = load_nsuri(window, nsuri, bscallback, LOAD_FLAGS_BYPASS_CACHE);
hres = load_nsuri(window, nsuri, NULL, bscallback, LOAD_FLAGS_BYPASS_CACHE);
nsISupports_Release((nsISupports*)nsuri); /* FIXME */
if(SUCCEEDED(hres)) {
hres = create_pending_window(window, bscallback);

434
reactos/dll/win32/mshtml/pluginhost.c
View file

@ -163,7 +163,7 @@ static void load_plugin(PluginHost *host)
FIXME("No IPersistPropertyBag iface\n");
}
static void activate_plugin(PluginHost *host)
static void initialize_plugin_object(PluginHost *host)
{
IClientSecurity *client_security;
IQuickActivate *quick_activate;
@ -172,12 +172,8 @@ static void activate_plugin(PluginHost *host)
IViewObjectEx *view_obj;
IDispatchEx *dispex;
IDispatch *disp;
RECT rect;
HRESULT hres;
if(!host->plugin_unk)
return;
/* Note native calls QI on plugin for an undocumented IID and CLSID_HTMLDocument */
/* FIXME: call FreezeEvents(TRUE) */
@ -262,6 +258,13 @@ static void activate_plugin(PluginHost *host)
FIXME("Use IOleCommandTarget\n");
IOleCommandTarget_Release(cmdtrg);
}
}
static void embed_plugin_object(PluginHost *host)
{
IOleObject *ole_obj;
RECT rect;
HRESULT hres;
hres = IUnknown_QueryInterface(host->plugin_unk, &IID_IOleObject, (void**)&ole_obj);
if(FAILED(hres)) {
@ -269,13 +272,11 @@ static void activate_plugin(PluginHost *host)
return;
}
if(ole_obj) {
get_pos_rect(host, &rect);
hres = IOleObject_DoVerb(ole_obj, OLEIVERB_INPLACEACTIVATE, NULL, &host->IOleClientSite_iface, 0, host->hwnd, &rect);
IOleObject_Release(ole_obj);
if(FAILED(hres))
WARN("DoVerb failed: %08x\n", hres);
}
get_pos_rect(host, &rect);
hres = IOleObject_DoVerb(ole_obj, OLEIVERB_INPLACEACTIVATE, NULL, &host->IOleClientSite_iface, 0, host->hwnd, &rect);
IOleObject_Release(ole_obj);
if(FAILED(hres))
WARN("DoVerb failed: %08x\n", hres);
if(host->ip_object) {
HWND hwnd;
@ -304,7 +305,7 @@ void update_plugin_window(PluginHost *host, HWND hwnd, const RECT *rect)
if(!host->hwnd) {
host->hwnd = hwnd;
activate_plugin(host);
embed_plugin_object(host);
}
if(rect_changed && host->ip_object)
@ -1615,29 +1616,378 @@ static const IServiceProviderVtbl ServiceProviderVtbl = {
PHServiceProvider_QueryService
};
static HRESULT assoc_element(PluginHost *host, HTMLDocumentNode *doc, nsIDOMElement *nselem)
static BOOL parse_classid(const PRUnichar *classid, CLSID *clsid)
{
HTMLPluginContainer *container_elem;
HTMLDOMNode *node;
const WCHAR *ptr;
unsigned len;
HRESULT hres;
hres = get_node(doc, (nsIDOMNode*)nselem, TRUE, &node);
if(FAILED(hres))
return hres;
static const PRUnichar clsidW[] = {'c','l','s','i','d',':'};
hres = IHTMLDOMNode_QueryInterface(&node->IHTMLDOMNode_iface, &IID_HTMLPluginContainer,
(void**)&container_elem);
node_release(node);
if(FAILED(hres)) {
ERR("Not an object element\n");
return hres;
if(strncmpiW(classid, clsidW, sizeof(clsidW)/sizeof(WCHAR)))
return FALSE;
ptr = classid + sizeof(clsidW)/sizeof(WCHAR);
len = strlenW(ptr);
if(len == 38) {
hres = CLSIDFromString(ptr, clsid);
}else if(len == 36) {
WCHAR buf[39];
buf[0] = '{';
memcpy(buf+1, ptr, len*sizeof(WCHAR));
buf[37] = '}';
buf[38] = 0;
hres = CLSIDFromString(buf, clsid);
}else {
return FALSE;
}
container_elem->plugin_host = host;
host->element = container_elem;
return SUCCEEDED(hres);
}
static BOOL get_elem_clsid(nsIDOMHTMLElement *elem, CLSID *clsid)
{
const PRUnichar *val;
nsAString val_str;
nsresult nsres;
BOOL ret = FALSE;
static const PRUnichar classidW[] = {'c','l','a','s','s','i','d',0};
nsres = get_elem_attr_value(elem, classidW, &val_str, &val);
if(NS_SUCCEEDED(nsres)) {
if(*val)
ret = parse_classid(val, clsid);
nsAString_Finish(&val_str);
}
return ret;
}
typedef struct {
IBindStatusCallback IBindStatusCallback_iface;
IWindowForBindingUI IWindowForBindingUI_iface;
LONG ref;
} InstallCallback;
static inline InstallCallback *impl_from_IBindStatusCallback(IBindStatusCallback *iface)
{
return CONTAINING_RECORD(iface, InstallCallback, IBindStatusCallback_iface);
}
static HRESULT WINAPI InstallCallback_QueryInterface(IBindStatusCallback *iface,
REFIID riid, void **ppv)
{
InstallCallback *This = impl_from_IBindStatusCallback(iface);
if(IsEqualGUID(&IID_IUnknown, riid)) {
TRACE("(%p)->(IID_IUnknown %p)\n", This, ppv);
*ppv = &This->IBindStatusCallback_iface;
}else if(IsEqualGUID(&IID_IBindStatusCallback, riid)) {
TRACE("(%p)->(IID_IBindStatusCallback %p)\n", This, ppv);
*ppv = &This->IBindStatusCallback_iface;
}else if(IsEqualGUID(&IID_IWindowForBindingUI, riid)) {
TRACE("(%p)->(IID_IWindowForBindingUI %p)\n", This, ppv);
*ppv = &This->IWindowForBindingUI_iface;
}else {
TRACE("(%p)->(%s %p)\n", This, debugstr_guid(riid), ppv);
*ppv = NULL;
return E_NOINTERFACE;
}
IUnknown_AddRef((IUnknown*)*ppv);
return S_OK;
}
static ULONG WINAPI InstallCallback_AddRef(IBindStatusCallback *iface)
{
InstallCallback *This = impl_from_IBindStatusCallback(iface);
LONG ref = InterlockedIncrement(&This->ref);
TRACE("(%p) ref=%d\n", This, ref);
return ref;
}
static ULONG WINAPI InstallCallback_Release(IBindStatusCallback *iface)
{
InstallCallback *This = impl_from_IBindStatusCallback(iface);
LONG ref = InterlockedIncrement(&This->ref);
TRACE("(%p) ref=%d\n", This, ref);
if(!ref)
heap_free(This);
return ref;
}
static HRESULT WINAPI InstallCallback_OnStartBinding(IBindStatusCallback *iface,
DWORD dwReserved, IBinding *pib)
{
InstallCallback *This = impl_from_IBindStatusCallback(iface);
TRACE("(%p)->(%x %p)\n", This, dwReserved, pib);
return S_OK;
}
static HRESULT WINAPI InstallCallback_GetPriority(IBindStatusCallback *iface, LONG *pnPriority)
{
InstallCallback *This = impl_from_IBindStatusCallback(iface);
TRACE("(%p)->(%p)\n", This, pnPriority);
return E_NOTIMPL;
}
static HRESULT WINAPI InstallCallback_OnLowResource(IBindStatusCallback *iface, DWORD dwReserved)
{
InstallCallback *This = impl_from_IBindStatusCallback(iface);
TRACE("(%p)->(%x)\n", This, dwReserved);
return S_OK;
}
static HRESULT WINAPI InstallCallback_OnProgress(IBindStatusCallback *iface, ULONG ulProgress,
ULONG ulProgressMax, ULONG ulStatusCode, LPCWSTR szStatusText)
{
InstallCallback *This = impl_from_IBindStatusCallback(iface);
TRACE("(%p)->(%u %u %u %s)\n", This, ulProgress, ulProgressMax, ulStatusCode, debugstr_w(szStatusText));
return S_OK;
}
static HRESULT WINAPI InstallCallback_OnStopBinding(IBindStatusCallback *iface,
HRESULT hresult, LPCWSTR szError)
{
InstallCallback *This = impl_from_IBindStatusCallback(iface);
TRACE("(%p)->(%08x %s)\n", This, hresult, debugstr_w(szError));
return S_OK;
}
static HRESULT WINAPI InstallCallback_GetBindInfo(IBindStatusCallback *iface,
DWORD* grfBINDF, BINDINFO* pbindinfo)
{
InstallCallback *This = impl_from_IBindStatusCallback(iface);
TRACE("(%p)->(%p %p)\n", This, grfBINDF, pbindinfo);
*grfBINDF = BINDF_ASYNCHRONOUS;
return S_OK;
}
static HRESULT WINAPI InstallCallback_OnDataAvailable(IBindStatusCallback *iface, DWORD grfBSCF,
DWORD dwSize, FORMATETC* pformatetc, STGMEDIUM* pstgmed)
{
InstallCallback *This = impl_from_IBindStatusCallback(iface);
ERR("(%p)\n", This);
return E_NOTIMPL;
}
static HRESULT WINAPI InstallCallback_OnObjectAvailable(IBindStatusCallback *iface,
REFIID riid, IUnknown* punk)
{
InstallCallback *This = impl_from_IBindStatusCallback(iface);
ERR("(%p)\n", This);
return E_NOTIMPL;
}
static IBindStatusCallbackVtbl InstallCallbackVtbl = {
InstallCallback_QueryInterface,
InstallCallback_AddRef,
InstallCallback_Release,
InstallCallback_OnStartBinding,
InstallCallback_GetPriority,
InstallCallback_OnLowResource,
InstallCallback_OnProgress,
InstallCallback_OnStopBinding,
InstallCallback_GetBindInfo,
InstallCallback_OnDataAvailable,
InstallCallback_OnObjectAvailable
};
static inline InstallCallback *impl_from_IWindowForBindingUI(IWindowForBindingUI *iface)
{
return CONTAINING_RECORD(iface, InstallCallback, IWindowForBindingUI_iface);
}
static HRESULT WINAPI WindowForBindingUI_QueryInterface(IWindowForBindingUI *iface, REFIID riid, void **ppv)
{
InstallCallback *This = impl_from_IWindowForBindingUI(iface);
return IBindStatusCallback_QueryInterface(&This->IBindStatusCallback_iface, riid, ppv);
}
static ULONG WINAPI WindowForBindingUI_AddRef(IWindowForBindingUI *iface)
{
InstallCallback *This = impl_from_IWindowForBindingUI(iface);
return IBindStatusCallback_AddRef(&This->IBindStatusCallback_iface);
}
static ULONG WINAPI WindowForBindingUI_Release(IWindowForBindingUI *iface)
{
InstallCallback *This = impl_from_IWindowForBindingUI(iface);
return IBindStatusCallback_Release(&This->IBindStatusCallback_iface);
}
static HRESULT WINAPI WindowForBindingUI_GetWindow(IWindowForBindingUI *iface, REFGUID rguidReason, HWND *phwnd)
{
InstallCallback *This = impl_from_IWindowForBindingUI(iface);
FIXME("(%p)->(%s %p)\n", This, debugstr_guid(rguidReason), phwnd);
*phwnd = NULL;
return S_OK;
}
static const IWindowForBindingUIVtbl WindowForBindingUIVtbl = {
WindowForBindingUI_QueryInterface,
WindowForBindingUI_AddRef,
WindowForBindingUI_Release,
WindowForBindingUI_GetWindow
};
typedef struct {
struct list entry;
IUri *uri;
} install_entry_t;
static struct list install_list = LIST_INIT(install_list);
static CRITICAL_SECTION cs_install_list;
static CRITICAL_SECTION_DEBUG cs_install_list_dbg =
{
0, 0, &cs_install_list,
{ &cs_install_list_dbg.ProcessLocksList, &cs_install_list_dbg.ProcessLocksList },
0, 0, { (DWORD_PTR)(__FILE__ ": install_list") }
};
static CRITICAL_SECTION cs_install_list = { &cs_install_list_dbg, -1, 0, 0, 0, 0 };
static void install_codebase(const WCHAR *url)
{
InstallCallback *callback;
IBindCtx *bctx;
HRESULT hres;
callback = heap_alloc(sizeof(*callback));
if(!callback)
return;
callback->IBindStatusCallback_iface.lpVtbl = &InstallCallbackVtbl;
callback->IWindowForBindingUI_iface.lpVtbl = &WindowForBindingUIVtbl;
callback->ref = 1;
hres = CreateAsyncBindCtx(0, &callback->IBindStatusCallback_iface, NULL, &bctx);
IBindStatusCallback_Release(&callback->IBindStatusCallback_iface);
if(FAILED(hres))
return;
hres = AsyncInstallDistributionUnit(NULL, NULL, NULL, 0, 0, url, bctx, NULL, 0);
IBindCtx_Release(bctx);
if(FAILED(hres))
WARN("FAILED: %08x\n", hres);
}
static void check_codebase(HTMLInnerWindow *window, nsIDOMHTMLElement *nselem)
{
BOOL is_on_list = FALSE;
install_entry_t *iter;
const PRUnichar *val;
nsAString val_str;
IUri *uri = NULL;
nsresult nsres;
HRESULT hres;
static const PRUnichar codebaseW[] = {'c','o','d','e','b','a','s','e',0};
nsres = get_elem_attr_value(nselem, codebaseW, &val_str, &val);
if(NS_SUCCEEDED(nsres)) {
if(*val) {
hres = CoInternetCombineUrlEx(window->base.outer_window->uri, val, 0, &uri, 0);
if(FAILED(hres))
uri = NULL;
}
nsAString_Finish(&val_str);
}
if(!uri)
return;
EnterCriticalSection(&cs_install_list);
LIST_FOR_EACH_ENTRY(iter, &install_list, install_entry_t, entry) {
BOOL eq;
hres = IUri_IsEqual(uri, iter->uri, &eq);
if(SUCCEEDED(hres) && eq) {
TRACE("already proceeded\n");
is_on_list = TRUE;
break;
}
}
if(!is_on_list) {
iter = heap_alloc(sizeof(*iter));
if(iter) {
IUri_AddRef(uri);
iter->uri = uri;
list_add_tail(&install_list, &iter->entry);
}
}
LeaveCriticalSection(&cs_install_list);
if(!is_on_list) {
BSTR display_uri;
hres = IUri_GetDisplayUri(uri, &display_uri);
if(SUCCEEDED(hres)) {
install_codebase(display_uri);
SysFreeString(display_uri);
}
}
IUri_Release(uri);
}
static IUnknown *create_activex_object(HTMLDocumentNode *doc, nsIDOMHTMLElement *nselem, CLSID *clsid)
{
IClassFactoryEx *cfex;
IClassFactory *cf;
IUnknown *obj;
DWORD policy;
HRESULT hres;
if(!get_elem_clsid(nselem, clsid)) {
WARN("Could not determine element CLSID\n");
return NULL;
}
TRACE("clsid %s\n", debugstr_guid(clsid));
policy = 0;
hres = IInternetHostSecurityManager_ProcessUrlAction(&doc->IInternetHostSecurityManager_iface,
URLACTION_ACTIVEX_RUN, (BYTE*)&policy, sizeof(policy), (BYTE*)clsid, sizeof(GUID), 0, 0);
if(FAILED(hres) || policy != URLPOLICY_ALLOW) {
WARN("ProcessUrlAction returned %08x %x\n", hres, policy);
return NULL;
}
hres = CoGetClassObject(clsid, CLSCTX_INPROC_SERVER|CLSCTX_LOCAL_SERVER, NULL, &IID_IClassFactory, (void**)&cf);
if(hres == REGDB_E_CLASSNOTREG)
check_codebase(doc->window, nselem);
if(FAILED(hres))
return NULL;
hres = IClassFactory_QueryInterface(cf, &IID_IClassFactoryEx, (void**)&cfex);
if(SUCCEEDED(hres)) {
FIXME("Use IClassFactoryEx\n");
IClassFactoryEx_Release(cfex);
}
hres = IClassFactory_CreateInstance(cf, NULL, &IID_IUnknown, (void**)&obj);
IClassFactory_Release(cf);
if(FAILED(hres))
return NULL;
return obj;
}
void detach_plugin_host(PluginHost *host)
{
HRESULT hres;
@ -1698,14 +2048,23 @@ void detach_plugin_host(PluginHost *host)
host->doc = NULL;
}
HRESULT create_plugin_host(HTMLDocumentNode *doc, nsIDOMElement *nselem, IUnknown *unk, const CLSID *clsid, PluginHost **ret)
HRESULT create_plugin_host(HTMLDocumentNode *doc, HTMLPluginContainer *container)
{
PluginHost *host;
HRESULT hres;
IUnknown *unk;
CLSID clsid;
assert(!container->plugin_host);
unk = create_activex_object(doc, container->element.nselem, &clsid);
if(!unk)
return E_FAIL;
host = heap_alloc_zero(sizeof(*host));
if(!host)
if(!host) {
IUnknown_Release(unk);
return E_OUTOFMEMORY;
}
host->IOleClientSite_iface.lpVtbl = &OleClientSiteVtbl;
host->IAdviseSinkEx_iface.lpVtbl = &AdviseSinkExVtbl;
@ -1718,19 +2077,16 @@ HRESULT create_plugin_host(HTMLDocumentNode *doc, nsIDOMElement *nselem, IUnknow
host->ref = 1;
hres = assoc_element(host, doc, nselem);
if(FAILED(hres)) {
heap_free(host);
return hres;
}
IUnknown_AddRef(unk);
host->plugin_unk = unk;
host->clsid = *clsid;
host->clsid = clsid;
host->doc = doc;
list_add_tail(&doc->plugin_hosts, &host->entry);
*ret = host;
container->plugin_host = host;
host->element = container;
initialize_plugin_object(host);
return S_OK;
}

2
reactos/dll/win32/mshtml/pluginhost.h
View file

@ -62,7 +62,7 @@ struct HTMLPluginContainer {
extern const IID IID_HTMLPluginContainer DECLSPEC_HIDDEN;
HRESULT create_plugin_host(HTMLDocumentNode*,nsIDOMElement*,IUnknown*,const CLSID*,PluginHost**) DECLSPEC_HIDDEN;
HRESULT create_plugin_host(HTMLDocumentNode*,HTMLPluginContainer*) DECLSPEC_HIDDEN;
void update_plugin_window(PluginHost*,HWND,const RECT*) DECLSPEC_HIDDEN;
void detach_plugin_host(PluginHost*) DECLSPEC_HIDDEN;

8
reactos/dll/win32/mshtml/protocol.c
View file

@ -578,9 +578,9 @@ static HRESULT WINAPI ResProtocol_Start(IInternetProtocol *iface, LPCWSTR szUrl,
DWORD grfPI, HANDLE_PTR dwReserved)
{
ResProtocol *This = ResProtocol_from_IInternetProtocol(iface);
WCHAR *url_dll, *url_file, *url, *mime, *res_type = (LPWSTR)RT_HTML, *ptr;
DWORD grfBINDF = 0, len;
BINDINFO bindinfo;
LPWSTR url_dll, url_file, url, mime, res_type = (LPWSTR)RT_HTML;
HMODULE hdll;
HRSRC src;
HRESULT hres;
@ -630,6 +630,12 @@ static HRESULT WINAPI ResProtocol_Start(IInternetProtocol *iface, LPCWSTR szUrl,
res_type = MAKEINTRESOURCEW(RT_HTML);
}
/* Ignore query and hash parts. */
if((ptr = strchrW(url_file, '?')))
*ptr = 0;
if(*url_file && (ptr = strchrW(url_file+1, '#')))
*ptr = 0;
hdll = LoadLibraryExW(url_dll, NULL, LOAD_LIBRARY_AS_DATAFILE);
if(!hdll) {
WARN("Could not open dll: %s\n", debugstr_w(url_dll));

295
reactos/dll/win32/mshtml/script.c
View file

@ -681,7 +681,61 @@ static ScriptHost *create_script_host(HTMLInnerWindow *window, const GUID *guid)
return ret;
}
static void parse_text(ScriptHost *script_host, LPCWSTR text)
typedef struct {
task_t header;
HTMLScriptElement *elem;
} fire_readystatechange_task_t;
static void fire_readystatechange_proc(task_t *_task)
{
fire_readystatechange_task_t *task = (fire_readystatechange_task_t*)_task;
if(!task->elem->pending_readystatechange_event)
return;
task->elem->pending_readystatechange_event = FALSE;
fire_event(task->elem->element.node.doc, EVENTID_READYSTATECHANGE, FALSE, task->elem->element.node.nsnode, NULL, NULL);
}
static void fire_readystatechange_task_destr(task_t *_task)
{
fire_readystatechange_task_t *task = (fire_readystatechange_task_t*)_task;
IHTMLScriptElement_Release(&task->elem->IHTMLScriptElement_iface);
}
static void set_script_elem_readystate(HTMLScriptElement *script_elem, READYSTATE readystate)
{
script_elem->readystate = readystate;
if(readystate != READYSTATE_INTERACTIVE) {
if(!script_elem->element.node.doc->window->parser_callback_cnt) {
fire_readystatechange_task_t *task;
HRESULT hres;
if(script_elem->pending_readystatechange_event)
return;
task = heap_alloc(sizeof(*task));
if(!task)
return;
IHTMLScriptElement_AddRef(&script_elem->IHTMLScriptElement_iface);
task->elem = script_elem;
hres = push_task(&task->header, fire_readystatechange_proc, fire_readystatechange_task_destr,
script_elem->element.node.doc->window->task_magic);
if(SUCCEEDED(hres))
script_elem->pending_readystatechange_event = TRUE;
}else {
script_elem->pending_readystatechange_event = FALSE;
fire_event(script_elem->element.node.doc, EVENTID_READYSTATECHANGE, FALSE,
script_elem->element.node.nsnode, NULL, NULL);
}
}
}
static void parse_elem_text(ScriptHost *script_host, HTMLScriptElement *script_elem, LPCWSTR text)
{
EXCEPINFO excepinfo;
VARIANT var;
@ -689,6 +743,8 @@ static void parse_text(ScriptHost *script_host, LPCWSTR text)
TRACE("%s\n", debugstr_w(text));
set_script_elem_readystate(script_elem, READYSTATE_INTERACTIVE);
VariantInit(&var);
memset(&excepinfo, 0, sizeof(excepinfo));
TRACE(">>>\n");
@ -702,27 +758,237 @@ static void parse_text(ScriptHost *script_host, LPCWSTR text)
}
static void parse_extern_script(ScriptHost *script_host, LPCWSTR src)
typedef struct {
BSCallback bsc;
HTMLScriptElement *script_elem;
DWORD scheme;
DWORD size;
char *buf;
HRESULT hres;
} ScriptBSC;
static inline ScriptBSC *impl_from_BSCallback(BSCallback *iface)
{
return CONTAINING_RECORD(iface, ScriptBSC, bsc);
}
static void ScriptBSC_destroy(BSCallback *bsc)
{
ScriptBSC *This = impl_from_BSCallback(bsc);
if(This->script_elem) {
IHTMLScriptElement_Release(&This->script_elem->IHTMLScriptElement_iface);
This->script_elem = NULL;
}
heap_free(This->buf);
heap_free(This);
}
static HRESULT ScriptBSC_init_bindinfo(BSCallback *bsc)
{
return S_OK;
}
static HRESULT ScriptBSC_start_binding(BSCallback *bsc)
{
ScriptBSC *This = impl_from_BSCallback(bsc);
/* FIXME: We should find a better to decide if 'loading' state is supposed to be used by the protocol. */
if(This->scheme == URL_SCHEME_HTTPS || This->scheme == URL_SCHEME_HTTP)
set_script_elem_readystate(This->script_elem, READYSTATE_LOADING);
return S_OK;
}
static HRESULT ScriptBSC_stop_binding(BSCallback *bsc, HRESULT result)
{
ScriptBSC *This = impl_from_BSCallback(bsc);
This->hres = result;
if(SUCCEEDED(result)) {
if(This->script_elem->readystate == READYSTATE_LOADING)
set_script_elem_readystate(This->script_elem, READYSTATE_LOADED);
}else {
FIXME("binding failed %08x\n", result);
heap_free(This->buf);
This->buf = NULL;
This->size = 0;
}
IHTMLScriptElement_Release(&This->script_elem->IHTMLScriptElement_iface);
This->script_elem = NULL;
return S_OK;
}
static HRESULT ScriptBSC_read_data(BSCallback *bsc, IStream *stream)
{
ScriptBSC *This = impl_from_BSCallback(bsc);
DWORD readed;
HRESULT hres;
if(!This->buf) {
This->buf = heap_alloc(128);
if(!This->buf)
return E_OUTOFMEMORY;
This->size = 128;
}
do {
if(This->bsc.readed >= This->size) {
void *new_buf;
new_buf = heap_realloc(This->buf, This->size << 1);
if(!new_buf)
return E_OUTOFMEMORY;
This->size <<= 1;
This->buf = new_buf;
}
hres = read_stream(&This->bsc, stream, This->buf+This->bsc.readed, This->size-This->bsc.readed, &readed);
}while(hres == S_OK);
return S_OK;
}
static HRESULT ScriptBSC_on_progress(BSCallback *bsc, ULONG status_code, LPCWSTR status_text)
{
return S_OK;
}
static HRESULT ScriptBSC_on_response(BSCallback *bsc, DWORD response_code,
LPCWSTR response_headers)
{
return S_OK;
}
static HRESULT ScriptBSC_beginning_transaction(BSCallback *bsc, WCHAR **additional_headers)
{
return S_FALSE;
}
static const BSCallbackVtbl ScriptBSCVtbl = {
ScriptBSC_destroy,
ScriptBSC_init_bindinfo,
ScriptBSC_start_binding,
ScriptBSC_stop_binding,
ScriptBSC_read_data,
ScriptBSC_on_progress,
ScriptBSC_on_response,
ScriptBSC_beginning_transaction
};
static HRESULT bind_script_to_text(HTMLInnerWindow *window, IUri *uri, HTMLScriptElement *script_elem, WCHAR **ret)
{
UINT cp = CP_UTF8;
ScriptBSC *bsc;
IMoniker *mon;
WCHAR *text;
HRESULT hres;
hres = CreateURLMonikerEx2(NULL, uri, &mon, URL_MK_UNIFORM);
if(FAILED(hres))
return hres;
bsc = heap_alloc_zero(sizeof(*bsc));
if(!bsc) {
IMoniker_Release(mon);
return E_OUTOFMEMORY;
}
init_bscallback(&bsc->bsc, &ScriptBSCVtbl, mon, 0);
IMoniker_Release(mon);
bsc->hres = E_FAIL;
hres = IUri_GetScheme(uri, &bsc->scheme);
if(FAILED(hres))
bsc->scheme = URL_SCHEME_UNKNOWN;
IHTMLScriptElement_AddRef(&script_elem->IHTMLScriptElement_iface);
bsc->script_elem = script_elem;
hres = start_binding(window, &bsc->bsc, NULL);
if(SUCCEEDED(hres))
hres = bsc->hres;
if(FAILED(hres)) {
IBindStatusCallback_Release(&bsc->bsc.IBindStatusCallback_iface);
return hres;
}
if(!bsc->bsc.readed) {
*ret = NULL;
return S_OK;
}
switch(bsc->bsc.bom) {
case BOM_UTF16:
if(bsc->bsc.readed % sizeof(WCHAR)) {
FIXME("The buffer is not a valid utf16 string\n");
hres = E_FAIL;
break;
}
text = heap_alloc(bsc->bsc.readed+sizeof(WCHAR));
if(!text) {
hres = E_OUTOFMEMORY;
break;
}
memcpy(text, bsc->buf, bsc->bsc.readed);
text[bsc->bsc.readed/sizeof(WCHAR)] = 0;
break;
default:
/* FIXME: Try to use charset from HTTP headers first */
cp = get_document_charset(window->doc);
/* fall through */
case BOM_UTF8: {
DWORD len;
len = MultiByteToWideChar(cp, 0, bsc->buf, bsc->bsc.readed, NULL, 0);
text = heap_alloc((len+1)*sizeof(WCHAR));
if(!text) {
hres = E_OUTOFMEMORY;
break;
}
MultiByteToWideChar(cp, 0, bsc->buf, bsc->bsc.readed, text, len);
text[len] = 0;
}
}
IBindStatusCallback_Release(&bsc->bsc.IBindStatusCallback_iface);
if(FAILED(hres))
return hres;
*ret = text;
return S_OK;
}
static void parse_extern_script(ScriptHost *script_host, HTMLScriptElement *script_elem, LPCWSTR src)
{
WCHAR *text;
IUri *uri;
HRESULT hres;
static const WCHAR wine_schemaW[] = {'w','i','n','e',':'};
if(strlenW(src) > sizeof(wine_schemaW)/sizeof(WCHAR) && !memcmp(src, wine_schemaW, sizeof(wine_schemaW)))
src += sizeof(wine_schemaW)/sizeof(WCHAR);
hres = CreateURLMoniker(NULL, src, &mon);
hres = create_uri(src, 0, &uri);
if(FAILED(hres))
return;
hres = bind_mon_to_wstr(script_host->window, mon, &text);
IMoniker_Release(mon);
if(FAILED(hres))
hres = bind_script_to_text(script_host->window, uri, script_elem, &text);
IUri_Release(uri);
if(FAILED(hres) || !text)
return;
parse_text(script_host, text);
parse_elem_text(script_host, script_elem, text);
heap_free(text);
}
@ -740,7 +1006,7 @@ static void parse_inline_script(ScriptHost *script_host, HTMLScriptElement *scri
if(NS_FAILED(nsres)) {
ERR("GetText failed: %08x\n", nsres);
}else if(*text) {
parse_text(script_host, text);
parse_elem_text(script_host, script_elem, text);
}
nsAString_Finish(&text_str);
@ -776,12 +1042,14 @@ static void parse_script_elem(ScriptHost *script_host, HTMLScriptElement *script
ERR("GetSrc failed: %08x\n", nsres);
}else if(*src) {
script_elem->parsed = TRUE;
parse_extern_script(script_host, src);
parse_extern_script(script_host, script_elem, src);
}else {
parse_inline_script(script_host, script_elem);
}
nsAString_Finish(&src_str);
set_script_elem_readystate(script_elem, READYSTATE_COMPLETE);
}
static GUID get_default_script_guid(HTMLInnerWindow *window)
@ -829,6 +1097,7 @@ static BOOL get_guid_from_language(LPCWSTR type, GUID *guid)
static BOOL get_script_guid(HTMLInnerWindow *window, nsIDOMHTMLScriptElement *nsscript, GUID *guid)
{
nsIDOMHTMLElement *nselem;
const PRUnichar *language;
nsAString val_str;
BOOL ret = FALSE;
@ -852,7 +1121,11 @@ static BOOL get_script_guid(HTMLInnerWindow *window, nsIDOMHTMLScriptElement *ns
ERR("GetType failed: %08x\n", nsres);
}
nsres = get_elem_attr_value((nsIDOMHTMLElement*)nsscript, languageW, &val_str, &language);
nsres = nsIDOMHTMLScriptElement_QueryInterface(nsscript, &IID_nsIDOMHTMLElement, (void**)&nselem);
assert(nsres == NS_OK);
nsres = get_elem_attr_value(nselem, languageW, &val_str, &language);
nsIDOMHTMLElement_Release(nselem);
if(NS_SUCCEEDED(nsres)) {
if(*language) {
ret = get_guid_from_language(language, guid);
@ -1172,7 +1445,7 @@ void bind_event_scripts(HTMLDocumentNode *doc)
return;
nsAString_InitDepend(&selector_str, selectorW);
nsres = nsIDOMNodeSelector_QuerySelectorAll(doc->nsnode_selector, &selector_str, &node_list);
nsres = nsIDOMHTMLDocument_QuerySelectorAll(doc->nsdoc, &selector_str, &node_list);
nsAString_Finish(&selector_str);
if(NS_FAILED(nsres)) {
ERR("QuerySelectorAll failed: %08x\n", nsres);

56
reactos/dll/win32/mshtml/selection.c
View file

@ -19,6 +19,7 @@
#include "mshtml_private.h"
typedef struct {
DispatchEx dispex;
IHTMLSelectionObject IHTMLSelectionObject_iface;
LONG ref;
@ -39,26 +40,24 @@ static HRESULT WINAPI HTMLSelectionObject_QueryInterface(IHTMLSelectionObject *i
{
HTMLSelectionObject *This = impl_from_IHTMLSelectionObject(iface);
*ppv = NULL;
TRACE("(%p)->(%s %p)\n", This, debugstr_mshtml_guid(riid), ppv);
if(IsEqualGUID(&IID_IUnknown, riid)) {
TRACE("(%p)->(IID_IUnknown %p)\n", This, ppv);
*ppv = &This->IHTMLSelectionObject_iface;
}else if(IsEqualGUID(&IID_IDispatch, riid)) {
TRACE("(%p)->(IID_IUnknown %p)\n", This, ppv);
*ppv = &This->IHTMLSelectionObject_iface;
}else if(IsEqualGUID(&IID_IHTMLSelectionObject, riid)) {
TRACE("(%p)->(IID_IUnknown %p)\n", This, ppv);
*ppv = &This->IHTMLSelectionObject_iface;
}else if(dispex_query_interface(&This->dispex, riid, ppv)) {
return *ppv ? S_OK : E_NOINTERFACE;
}else {
*ppv = NULL;
WARN("(%p)->(%s %p)\n", This, debugstr_guid(riid), ppv);
return E_NOINTERFACE;
}
if(*ppv) {
IUnknown_AddRef((IUnknown*)*ppv);
return S_OK;
}
WARN("(%p)->(%s %p)\n", This, debugstr_guid(riid), ppv);
return E_NOINTERFACE;
IUnknown_AddRef((IUnknown*)*ppv);
return S_OK;
}
static ULONG WINAPI HTMLSelectionObject_AddRef(IHTMLSelectionObject *iface)
@ -83,6 +82,7 @@ static ULONG WINAPI HTMLSelectionObject_Release(IHTMLSelectionObject *iface)
nsISelection_Release(This->nsselection);
if(This->doc)
list_remove(&This->entry);
release_dispex(&This->dispex);
heap_free(This);
}
@ -92,16 +92,16 @@ static ULONG WINAPI HTMLSelectionObject_Release(IHTMLSelectionObject *iface)
static HRESULT WINAPI HTMLSelectionObject_GetTypeInfoCount(IHTMLSelectionObject *iface, UINT *pctinfo)
{
HTMLSelectionObject *This = impl_from_IHTMLSelectionObject(iface);
FIXME("(%p)->(%p)\n", This, pctinfo);
return E_NOTIMPL;
return IDispatchEx_GetTypeInfoCount(&This->dispex.IDispatchEx_iface, pctinfo);
}
static HRESULT WINAPI HTMLSelectionObject_GetTypeInfo(IHTMLSelectionObject *iface, UINT iTInfo,
LCID lcid, ITypeInfo **ppTInfo)
{
HTMLSelectionObject *This = impl_from_IHTMLSelectionObject(iface);
FIXME("(%p)->(%u %u %p)\n", This, iTInfo, lcid, ppTInfo);
return E_NOTIMPL;
return IDispatchEx_GetTypeInfo(&This->dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
}
static HRESULT WINAPI HTMLSelectionObject_GetIDsOfNames(IHTMLSelectionObject *iface, REFIID riid,
@ -109,9 +109,9 @@ static HRESULT WINAPI HTMLSelectionObject_GetIDsOfNames(IHTMLSelectionObject *if
LCID lcid, DISPID *rgDispId)
{
HTMLSelectionObject *This = impl_from_IHTMLSelectionObject(iface);
FIXME("(%p)->(%s %p %u %u %p)\n", This, debugstr_guid(riid), rgszNames, cNames,
lcid, rgDispId);
return E_NOTIMPL;
return IDispatchEx_GetIDsOfNames(&This->dispex.IDispatchEx_iface, riid, rgszNames,
cNames, lcid, rgDispId);
}
static HRESULT WINAPI HTMLSelectionObject_Invoke(IHTMLSelectionObject *iface, DISPID dispIdMember,
@ -119,9 +119,10 @@ static HRESULT WINAPI HTMLSelectionObject_Invoke(IHTMLSelectionObject *iface, DI
VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
{
HTMLSelectionObject *This = impl_from_IHTMLSelectionObject(iface);
FIXME("(%p)->(%d %s %d %d %p %p %p %p)\n", This, dispIdMember, debugstr_guid(riid),
lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
return E_NOTIMPL;
return IDispatchEx_Invoke(&This->dispex.IDispatchEx_iface, dispIdMember, riid,
lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
}
static HRESULT WINAPI HTMLSelectionObject_createRange(IHTMLSelectionObject *iface, IDispatch **range)
@ -220,6 +221,17 @@ static const IHTMLSelectionObjectVtbl HTMLSelectionObjectVtbl = {
HTMLSelectionObject_get_type
};
static const tid_t HTMLSelectionObject_iface_tids[] = {
IHTMLSelectionObject_tid,
0
};
static dispex_static_data_t HTMLSelectionObject_dispex = {
NULL,
IHTMLSelectionObject_tid,
NULL,
HTMLSelectionObject_iface_tids
};
HRESULT HTMLSelectionObject_Create(HTMLDocumentNode *doc, nsISelection *nsselection, IHTMLSelectionObject **ret)
{
HTMLSelectionObject *selection;
@ -228,6 +240,8 @@ HRESULT HTMLSelectionObject_Create(HTMLDocumentNode *doc, nsISelection *nsselect
if(!selection)
return E_OUTOFMEMORY;
init_dispex(&selection->dispex, (IUnknown*)&selection->IHTMLSelectionObject_iface, &HTMLSelectionObject_dispex);
selection->IHTMLSelectionObject_iface.lpVtbl = &HTMLSelectionObjectVtbl;
selection->ref = 1;
selection->nsselection = nsselection; /* We shouldn't call AddRef here */

57
reactos/dll/win32/mshtml/task.c
View file

@ -52,14 +52,8 @@ HRESULT push_task(task_t *task, task_proc_t proc, task_proc_t destr, LONG magic)
task->target_magic = magic;
task->proc = proc;
task->destr = destr ? destr : default_task_destr;
task->next = NULL;
if(thread_data->task_queue_tail)
thread_data->task_queue_tail->next = task;
else
thread_data->task_queue_head = task;
thread_data->task_queue_tail = task;
list_add_tail(&thread_data->task_list, &task->entry);
PostMessageW(thread_data->thread_hwnd, WM_PROCESSTASK, 0, 0);
return S_OK;
@ -74,14 +68,11 @@ static task_t *pop_task(void)
if(!thread_data)
return NULL;
task = thread_data->task_queue_head;
if(!task)
if(list_empty(&thread_data->task_list))
return NULL;
thread_data->task_queue_head = task->next;
if(!thread_data->task_queue_head)
thread_data->task_queue_tail = NULL;
task = LIST_ENTRY(thread_data->task_list.next, task_t, entry);
list_remove(&task->entry);
return task;
}
@ -94,12 +85,31 @@ static void release_task_timer(HWND thread_hwnd, task_timer_t *timer)
heap_free(timer);
}
void flush_pending_tasks(LONG target)
{
thread_data_t *thread_data = get_thread_data(FALSE);
struct list *liter, *ltmp;
task_t *task;
if(!thread_data)
return;
LIST_FOR_EACH_SAFE(liter, ltmp, &thread_data->task_list) {
task = LIST_ENTRY(liter, task_t, entry);
if(task->target_magic == target) {
list_remove(&task->entry);
task->proc(task);
task->destr(task);
}
}
}
void remove_target_tasks(LONG target)
{
thread_data_t *thread_data = get_thread_data(FALSE);
struct list *liter, *ltmp;
task_timer_t *timer;
task_t *iter, *tmp;
task_t *task;
if(!thread_data)
return;
@ -117,20 +127,12 @@ void remove_target_tasks(LONG target)
SetTimer(thread_data->thread_hwnd, TIMER_ID, max( (int)(timer->time - tc), 0 ), NULL);
}
while(thread_data->task_queue_head && thread_data->task_queue_head->target_magic == target) {
iter = pop_task();
iter->destr(iter);
}
for(iter = thread_data->task_queue_head; iter; iter = iter->next) {
while(iter->next && iter->next->target_magic == target) {
tmp = iter->next;
iter->next = tmp->next;
tmp->destr(tmp);
LIST_FOR_EACH_SAFE(liter, ltmp, &thread_data->task_list) {
task = LIST_ENTRY(liter, task_t, entry);
if(task->target_magic == target) {
list_remove(&task->entry);
task->destr(task);
}
if(!iter->next)
thread_data->task_queue_tail = iter;
}
}
@ -373,6 +375,7 @@ thread_data_t *get_thread_data(BOOL create)
return NULL;
TlsSetValue(mshtml_tls, thread_data);
list_init(&thread_data->task_list);
list_init(&thread_data->timer_list);
}

1329
reactos/dll/win32/mshtml/txtrange.c
View file

File diff suppressed because it is too large Load diff

4
reactos/media/doc/README.WINE
View file

@ -2,7 +2,7 @@
# Update this file when you port a dll/program from WINE.
The ReactOS Project shares quite a bit of code with the WINE project.
This document should provide a compleate reference for all of the
This document should provide a complete reference for all of the
locations in the ReactOS source tree where code is shared between the
two projects. If you find something is missing from this documentation
please add it.
@ -121,7 +121,7 @@ reactos/dll/win32/msctf # Synced to Wine-1.7.27
reactos/dll/win32/msftedit # Synced to Wine-1.7.27
reactos/dll/win32/msg711.acm # Synced to Wine-1.7.27
reactos/dll/win32/msgsm32.acm # Synced to Wine-1.7.27
reactos/dll/win32/mshtml # Synced to Wine-1.7.27
reactos/dll/win32/mshtml # Synced to WineStaging-1.7.37
reactos/dll/win32/mshtml.tlb # Synced to Wine-1.7.27
reactos/dll/win32/msi # Synced to WineStaging-1.7.37
reactos/dll/win32/msimg32 # Synced to Wine-1.7.27