dlls/mshtml/htmltextnode.c

   1 /*
   2  * Copyright 2008 Jacek Caban for CodeWeavers
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  17  */
  18
  19
  20 #include <stdarg.h>
  21 #include <assert.h>
  22
  23 #define COBJMACROS
  24
  25 #include "windef.h"
  26 #include "winbase.h"
  27 #include "winuser.h"
  28 #include "ole2.h"
  29
  30 #include "mshtml_private.h"
  31
  32 #include "wine/debug.h"
  33
  34 WINE_DEFAULT_DEBUG_CHANNEL(mshtml);
  35
  36 struct HTMLDOMTextNode {
  37     HTMLDOMNode node;
  38     IHTMLDOMTextNode IHTMLDOMTextNode_iface;
  39     IHTMLDOMTextNode2 IHTMLDOMTextNode2_iface;
  40
  41     nsIDOMText *nstext;
  42 };
  43
  44 static inline HTMLDOMTextNode *impl_from_IHTMLDOMTextNode(IHTMLDOMTextNode *iface)
  45 {
  46     return CONTAINING_RECORD(iface, HTMLDOMTextNode, IHTMLDOMTextNode_iface);
  47 }
  48
  49 static HRESULT WINAPI HTMLDOMTextNode_QueryInterface(IHTMLDOMTextNode *iface,
  50                                                  REFIID riid, void **ppv)
  51 {
  52     HTMLDOMTextNode *This = impl_from_IHTMLDOMTextNode(iface);
  53
  54     return IHTMLDOMNode_QueryInterface(&This->node.IHTMLDOMNode_iface, riid, ppv);
  55 }
  56
  57 static ULONG WINAPI HTMLDOMTextNode_AddRef(IHTMLDOMTextNode *iface)
  58 {
  59     HTMLDOMTextNode *This = impl_from_IHTMLDOMTextNode(iface);
  60
  61     return IHTMLDOMNode_AddRef(&This->node.IHTMLDOMNode_iface);
  62 }
  63
  64 static ULONG WINAPI HTMLDOMTextNode_Release(IHTMLDOMTextNode *iface)
  65 {
  66     HTMLDOMTextNode *This = impl_from_IHTMLDOMTextNode(iface);
  67
  68     return IHTMLDOMNode_Release(&This->node.IHTMLDOMNode_iface);
  69 }
  70
  71 static HRESULT WINAPI HTMLDOMTextNode_GetTypeInfoCount(IHTMLDOMTextNode *iface, UINT *pctinfo)
  72 {
  73     HTMLDOMTextNode *This = impl_from_IHTMLDOMTextNode(iface);
  74     return IDispatchEx_GetTypeInfoCount(&This->node.dispex.IDispatchEx_iface, pctinfo);
  75 }
  76
  77 static HRESULT WINAPI HTMLDOMTextNode_GetTypeInfo(IHTMLDOMTextNode *iface, UINT iTInfo,
  78                                               LCID lcid, ITypeInfo **ppTInfo)
  79 {
  80     HTMLDOMTextNode *This = impl_from_IHTMLDOMTextNode(iface);
  81     return IDispatchEx_GetTypeInfo(&This->node.dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
  82 }
  83
  84 static HRESULT WINAPI HTMLDOMTextNode_GetIDsOfNames(IHTMLDOMTextNode *iface, REFIID riid,
  85                                                 LPOLESTR *rgszNames, UINT cNames,
  86                                                 LCID lcid, DISPID *rgDispId)
  87 {
  88     HTMLDOMTextNode *This = impl_from_IHTMLDOMTextNode(iface);
  89     return IDispatchEx_GetIDsOfNames(&This->node.dispex.IDispatchEx_iface, riid, rgszNames, cNames,
  90             lcid, rgDispId);
  91 }
  92
  93 static HRESULT WINAPI HTMLDOMTextNode_Invoke(IHTMLDOMTextNode *iface, DISPID dispIdMember,
  94                             REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
  95                             VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
  96 {
  97     HTMLDOMTextNode *This = impl_from_IHTMLDOMTextNode(iface);
  98     return IDispatchEx_Invoke(&This->node.dispex.IDispatchEx_iface, dispIdMember, riid, lcid,
  99             wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
 100 }
 101
 102 static HRESULT WINAPI HTMLDOMTextNode_put_data(IHTMLDOMTextNode *iface, BSTR v)
 103 {
 104     HTMLDOMTextNode *This = impl_from_IHTMLDOMTextNode(iface);
 105     nsAString nsstr;
 106     nsresult nsres;
 107
 108     TRACE("(%p)->(%s)\n", This, debugstr_w(v));
 109
 110     nsAString_InitDepend(&nsstr, v);
 111     nsres = nsIDOMText_SetData(This->nstext, &nsstr);
 112     nsAString_Finish(&nsstr);
 113     return NS_SUCCEEDED(nsres) ? S_OK : E_FAIL;
 114 }
 115
 116 static HRESULT WINAPI HTMLDOMTextNode_get_data(IHTMLDOMTextNode *iface, BSTR *p)
 117 {
 118     HTMLDOMTextNode *This = impl_from_IHTMLDOMTextNode(iface);
 119     nsAString nsstr;
 120     nsresult nsres;
 121
 122     TRACE("(%p)->(%p)\n", This, p);
 123
 124     nsAString_Init(&nsstr, NULL);
 125     nsres = nsIDOMText_GetData(This->nstext, &nsstr);
 126     return return_nsstr(nsres, &nsstr, p);
 127 }
 128
 129 static HRESULT WINAPI HTMLDOMTextNode_toString(IHTMLDOMTextNode *iface, BSTR *String)
 130 {
 131     HTMLDOMTextNode *This = impl_from_IHTMLDOMTextNode(iface);
 132     FIXME("(%p)->(%p)\n", This, String);
 133     return E_NOTIMPL;
 134 }
 135
 136 static HRESULT WINAPI HTMLDOMTextNode_get_length(IHTMLDOMTextNode *iface, LONG *p)
 137 {
 138     HTMLDOMTextNode *This = impl_from_IHTMLDOMTextNode(iface);
 139     UINT32 length = 0;
 140     nsresult nsres;
 141
 142     TRACE("(%p)->(%p)\n", This, p);
 143
 144     nsres = nsIDOMText_GetLength(This->nstext, &length);
 145     if(NS_FAILED(nsres))
 146         ERR("GetLength failed: %08x\n", nsres);
 147
 148     *p = length;
 149     return S_OK;
 150 }
 151
 152 static HRESULT WINAPI HTMLDOMTextNode_splitText(IHTMLDOMTextNode *iface, LONG offset, IHTMLDOMNode **pRetNode)
 153 {
 154     HTMLDOMTextNode *This = impl_from_IHTMLDOMTextNode(iface);
 155     HTMLDOMNode *node;
 156     nsIDOMText *text;
 157     nsresult nsres;
 158     HRESULT hres;
 159
 160     TRACE("(%p)->(%d %p)\n", This, offset, pRetNode);
 161
 162     nsres = nsIDOMText_SplitText(This->nstext, offset, &text);
 163     if(NS_FAILED(nsres)) {
 164         ERR("SplitText failed: %x08x\n", nsres);
 165         return E_FAIL;
 166     }
 167
 168     if(!text) {
 169         *pRetNode = NULL;
 170         return S_OK;
 171     }
 172
 173     hres = get_node(This->node.doc, (nsIDOMNode*)text, TRUE, &node);
 174     nsIDOMText_Release(text);
 175     if(FAILED(hres))
 176         return hres;
 177
 178     *pRetNode = &node->IHTMLDOMNode_iface;
 179     return S_OK;
 180 }
 181
 182 static const IHTMLDOMTextNodeVtbl HTMLDOMTextNodeVtbl = {
 183     HTMLDOMTextNode_QueryInterface,
 184     HTMLDOMTextNode_AddRef,
 185     HTMLDOMTextNode_Release,
 186     HTMLDOMTextNode_GetTypeInfoCount,
 187     HTMLDOMTextNode_GetTypeInfo,
 188     HTMLDOMTextNode_GetIDsOfNames,
 189     HTMLDOMTextNode_Invoke,
 190     HTMLDOMTextNode_put_data,
 191     HTMLDOMTextNode_get_data,
 192     HTMLDOMTextNode_toString,
 193     HTMLDOMTextNode_get_length,
 194     HTMLDOMTextNode_splitText
 195 };
 196
 197 static inline HTMLDOMTextNode *impl_from_IHTMLDOMTextNode2(IHTMLDOMTextNode2 *iface)
 198 {
 199     return CONTAINING_RECORD(iface, HTMLDOMTextNode, IHTMLDOMTextNode2_iface);
 200 }
 201
 202 static HRESULT WINAPI HTMLDOMTextNode2_QueryInterface(IHTMLDOMTextNode2 *iface, REFIID riid, void **ppv)
 203 {
 204     HTMLDOMTextNode *This = impl_from_IHTMLDOMTextNode2(iface);
 205
 206     return IHTMLDOMNode_QueryInterface(&This->node.IHTMLDOMNode_iface, riid, ppv);
 207 }
 208
 209 static ULONG WINAPI HTMLDOMTextNode2_AddRef(IHTMLDOMTextNode2 *iface)
 210 {
 211     HTMLDOMTextNode *This = impl_from_IHTMLDOMTextNode2(iface);
 212
 213     return IHTMLDOMNode_AddRef(&This->node.IHTMLDOMNode_iface);
 214 }
 215
 216 static ULONG WINAPI HTMLDOMTextNode2_Release(IHTMLDOMTextNode2 *iface)
 217 {
 218     HTMLDOMTextNode *This = impl_from_IHTMLDOMTextNode2(iface);
 219
 220     return IHTMLDOMNode_Release(&This->node.IHTMLDOMNode_iface);
 221 }
 222
 223 static HRESULT WINAPI HTMLDOMTextNode2_GetTypeInfoCount(IHTMLDOMTextNode2 *iface, UINT *pctinfo)
 224 {
 225     HTMLDOMTextNode *This = impl_from_IHTMLDOMTextNode2(iface);
 226     return IDispatchEx_GetTypeInfoCount(&This->node.dispex.IDispatchEx_iface, pctinfo);
 227 }
 228
 229 static HRESULT WINAPI HTMLDOMTextNode2_GetTypeInfo(IHTMLDOMTextNode2 *iface, UINT iTInfo,
 230         LCID lcid, ITypeInfo **ppTInfo)
 231 {
 232     HTMLDOMTextNode *This = impl_from_IHTMLDOMTextNode2(iface);
 233     return IDispatchEx_GetTypeInfo(&This->node.dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
 234 }
 235
 236 static HRESULT WINAPI HTMLDOMTextNode2_GetIDsOfNames(IHTMLDOMTextNode2 *iface, REFIID riid,
 237         LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
 238 {
 239     HTMLDOMTextNode *This = impl_from_IHTMLDOMTextNode2(iface);
 240     return IDispatchEx_GetIDsOfNames(&This->node.dispex.IDispatchEx_iface, riid, rgszNames, cNames,
 241             lcid, rgDispId);
 242 }
 243
 244 static HRESULT WINAPI HTMLDOMTextNode2_Invoke(IHTMLDOMTextNode2 *iface, DISPID dispIdMember,
 245         REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult,
 246         EXCEPINFO *pExcepInfo, UINT *puArgErr)
 247 {
 248     HTMLDOMTextNode *This = impl_from_IHTMLDOMTextNode2(iface);
 249     return IDispatchEx_Invoke(&This->node.dispex.IDispatchEx_iface, dispIdMember, riid, lcid,
 250             wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
 251 }
 252
 253 static HRESULT WINAPI HTMLDOMTextNode2_substringData(IHTMLDOMTextNode2 *iface, LONG offset, LONG count, BSTR *string)
 254 {
 255     HTMLDOMTextNode *This = impl_from_IHTMLDOMTextNode2(iface);
 256     FIXME("(%p)->(%d %d %p)\n", This, offset, count, string);
 257     return E_NOTIMPL;
 258 }
 259
 260 static HRESULT WINAPI HTMLDOMTextNode2_appendData(IHTMLDOMTextNode2 *iface, BSTR string)
 261 {
 262     HTMLDOMTextNode *This = impl_from_IHTMLDOMTextNode2(iface);
 263     nsAString nsstr;
 264     nsresult nsres;
 265
 266     TRACE("(%p)->(%s)\n", This, debugstr_w(string));
 267
 268     nsAString_InitDepend(&nsstr, string);
 269     nsres = nsIDOMText_AppendData(This->nstext, &nsstr);
 270     nsAString_Finish(&nsstr);
 271     if(NS_FAILED(nsres)) {
 272         ERR("AppendData failed: %08x\n", nsres);
 273         return E_FAIL;
 274     }
 275
 276     return S_OK;
 277 }
 278
 279 static HRESULT WINAPI HTMLDOMTextNode2_insertData(IHTMLDOMTextNode2 *iface, LONG offset, BSTR string)
 280 {
 281     HTMLDOMTextNode *This = impl_from_IHTMLDOMTextNode2(iface);
 282     FIXME("(%p)->(%d %s)\n", This, offset, debugstr_w(string));
 283     return E_NOTIMPL;
 284 }
 285
 286 static HRESULT WINAPI HTMLDOMTextNode2_deleteData(IHTMLDOMTextNode2 *iface, LONG offset, LONG count)
 287 {
 288     HTMLDOMTextNode *This = impl_from_IHTMLDOMTextNode2(iface);
 289     FIXME("(%p)->(%d %d)\n", This, offset, count);
 290     return E_NOTIMPL;
 291 }
 292
 293 static HRESULT WINAPI HTMLDOMTextNode2_replaceData(IHTMLDOMTextNode2 *iface, LONG offset, LONG count, BSTR string)
 294 {
 295     HTMLDOMTextNode *This = impl_from_IHTMLDOMTextNode2(iface);
 296     FIXME("(%p)->(%d %d %s)\n", This, offset, count, debugstr_w(string));
 297     return E_NOTIMPL;
 298 }
 299
 300 static const IHTMLDOMTextNode2Vtbl HTMLDOMTextNode2Vtbl = {
 301     HTMLDOMTextNode2_QueryInterface,
 302     HTMLDOMTextNode2_AddRef,
 303     HTMLDOMTextNode2_Release,
 304     HTMLDOMTextNode2_GetTypeInfoCount,
 305     HTMLDOMTextNode2_GetTypeInfo,
 306     HTMLDOMTextNode2_GetIDsOfNames,
 307     HTMLDOMTextNode2_Invoke,
 308     HTMLDOMTextNode2_substringData,
 309     HTMLDOMTextNode2_appendData,
 310     HTMLDOMTextNode2_insertData,
 311     HTMLDOMTextNode2_deleteData,
 312     HTMLDOMTextNode2_replaceData
 313 };
 314
 315 static inline HTMLDOMTextNode *impl_from_HTMLDOMNode(HTMLDOMNode *iface)
 316 {
 317     return CONTAINING_RECORD(iface, HTMLDOMTextNode, node);
 318 }
 319
 320 static HRESULT HTMLDOMTextNode_QI(HTMLDOMNode *iface, REFIID riid, void **ppv)
 321 {
 322     HTMLDOMTextNode *This = impl_from_HTMLDOMNode(iface);
 323
 324     TRACE("(%p)->(%s %p)\n", This, debugstr_mshtml_guid(riid), ppv);
 325
 326     if(IsEqualGUID(&IID_IHTMLDOMTextNode, riid))
 327         *ppv = &This->IHTMLDOMTextNode_iface;
 328     else if(IsEqualGUID(&IID_IHTMLDOMTextNode2, riid))
 329         *ppv = &This->IHTMLDOMTextNode2_iface;
 330     else
 331         return HTMLDOMNode_QI(&This->node, riid, ppv);
 332
 333     IUnknown_AddRef((IUnknown*)*ppv);
 334     return S_OK;
 335 }
 336
 337 static HRESULT HTMLDOMTextNode_clone(HTMLDOMNode *iface, nsIDOMNode *nsnode, HTMLDOMNode **ret)
 338 {
 339     HTMLDOMTextNode *This = impl_from_HTMLDOMNode(iface);
 340
 341     return HTMLDOMTextNode_Create(This->node.doc, nsnode, ret);
 342 }
 343
 344 static const cpc_entry_t HTMLDOMTextNode_cpc[] = {{NULL}};
 345
 346 static const NodeImplVtbl HTMLDOMTextNodeImplVtbl = {
 347     HTMLDOMTextNode_QI,
 348     HTMLDOMNode_destructor,
 349     HTMLDOMTextNode_cpc,
 350     HTMLDOMTextNode_clone
 351 };
 352
 353 static const tid_t HTMLDOMTextNode_iface_tids[] = {
 354     IHTMLDOMNode_tid,
 355     IHTMLDOMNode2_tid,
 356     IHTMLDOMTextNode_tid,
 357     IHTMLDOMTextNode2_tid,
 358     0
 359 };
 360 static dispex_static_data_t HTMLDOMTextNode_dispex = {
 361     NULL,
 362     DispHTMLDOMTextNode_tid,
 363     0,
 364     HTMLDOMTextNode_iface_tids
 365 };
 366
 367 HRESULT HTMLDOMTextNode_Create(HTMLDocumentNode *doc, nsIDOMNode *nsnode, HTMLDOMNode **node)
 368 {
 369     HTMLDOMTextNode *ret;
 370     nsresult nsres;
 371
 372     ret = heap_alloc_zero(sizeof(*ret));
 373     if(!ret)
 374         return E_OUTOFMEMORY;
 375
 376     ret->node.vtbl = &HTMLDOMTextNodeImplVtbl;
 377     ret->IHTMLDOMTextNode_iface.lpVtbl = &HTMLDOMTextNodeVtbl;
 378     ret->IHTMLDOMTextNode2_iface.lpVtbl = &HTMLDOMTextNode2Vtbl;
 379
 380     init_dispex(&ret->node.dispex, (IUnknown*)&ret->IHTMLDOMTextNode_iface,
 381             &HTMLDOMTextNode_dispex);
 382
 383     HTMLDOMNode_Init(doc, &ret->node, nsnode);
 384
 385     nsres = nsIDOMNode_QueryInterface(nsnode, &IID_nsIDOMText, (void**)&ret->nstext);
 386     assert(nsres == NS_OK && (nsIDOMNode*)ret->nstext == ret->node.nsnode);
 387
 388     /* Share reference with nsnode */
 389     nsIDOMNode_Release(ret->node.nsnode);
 390
 391     *node = &ret->node;
 392     return S_OK;
 393 }