dll/win32/msxml3/cdata.c

   1 /*
   2  *    DOM CDATA node implementation
   3  *
   4  * Copyright 2007 Alistair Leslie-Hughes
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #define WIN32_NO_STATUS
  22 #define _INC_WINDOWS
  23
  24 #define COBJMACROS
  25
  26 #include <config.h>
  27
  28 //#include <stdarg.h>
  29 #ifdef HAVE_LIBXML2
  30 # include <libxml/parser.h>
  31 //# include <libxml/xmlerror.h>
  32 #endif
  33
  34 #include <windef.h>
  35 #include <winbase.h>
  36 //#include "winuser.h"
  37 #include <ole2.h>
  38 #include <msxml6.h>
  39
  40 #include "msxml_private.h"
  41
  42 #include <wine/debug.h>
  43
  44 WINE_DEFAULT_DEBUG_CHANNEL(msxml);
  45
  46 #ifdef HAVE_LIBXML2
  47
  48 typedef struct
  49 {
  50     xmlnode node;
  51     IXMLDOMCDATASection IXMLDOMCDATASection_iface;
  52     LONG ref;
  53 } domcdata;
  54
  55 static const tid_t domcdata_se_tids[] = {
  56     IXMLDOMNode_tid,
  57     IXMLDOMCDATASection_tid,
  58     0
  59 };
  60
  61 static inline domcdata *impl_from_IXMLDOMCDATASection( IXMLDOMCDATASection *iface )
  62 {
  63     return CONTAINING_RECORD(iface, domcdata, IXMLDOMCDATASection_iface);
  64 }
  65
  66 static HRESULT WINAPI domcdata_QueryInterface(
  67     IXMLDOMCDATASection *iface,
  68     REFIID riid,
  69     void** ppvObject )
  70 {
  71     domcdata *This = impl_from_IXMLDOMCDATASection( iface );
  72     TRACE("(%p)->(%s %p)\n", This, debugstr_guid(riid), ppvObject);
  73
  74     if ( IsEqualGUID( riid, &IID_IXMLDOMCDATASection ) ||
  75          IsEqualGUID( riid, &IID_IXMLDOMCharacterData) ||
  76          IsEqualGUID( riid, &IID_IXMLDOMNode ) ||
  77          IsEqualGUID( riid, &IID_IDispatch ) ||
  78          IsEqualGUID( riid, &IID_IUnknown ) )
  79     {
  80         *ppvObject = iface;
  81     }
  82     else if(node_query_interface(&This->node, riid, ppvObject))
  83     {
  84         return *ppvObject ? S_OK : E_NOINTERFACE;
  85     }
  86     else if(IsEqualGUID( riid, &IID_ISupportErrorInfo ))
  87     {
  88         return node_create_supporterrorinfo(domcdata_se_tids, ppvObject);
  89     }
  90     else
  91     {
  92         TRACE("Unsupported interface %s\n", debugstr_guid(riid));
  93         *ppvObject = NULL;
  94         return E_NOINTERFACE;
  95     }
  96
  97     IXMLDOMCDATASection_AddRef(iface);
  98     return S_OK;
  99 }
 100
 101 static ULONG WINAPI domcdata_AddRef(
 102     IXMLDOMCDATASection *iface )
 103 {
 104     domcdata *This = impl_from_IXMLDOMCDATASection( iface );
 105     ULONG ref = InterlockedIncrement( &This->ref );
 106     TRACE("(%p)->(%d)\n", This, ref);
 107     return ref;
 108 }
 109
 110 static ULONG WINAPI domcdata_Release(
 111     IXMLDOMCDATASection *iface )
 112 {
 113     domcdata *This = impl_from_IXMLDOMCDATASection( iface );
 114     ULONG ref = InterlockedDecrement( &This->ref );
 115
 116     TRACE("(%p)->(%d)\n", This, ref);
 117     if ( ref == 0 )
 118     {
 119         destroy_xmlnode(&This->node);
 120         heap_free( This );
 121     }
 122
 123     return ref;
 124 }
 125
 126 static HRESULT WINAPI domcdata_GetTypeInfoCount(
 127     IXMLDOMCDATASection *iface,
 128     UINT* pctinfo )
 129 {
 130     domcdata *This = impl_from_IXMLDOMCDATASection( iface );
 131     return IDispatchEx_GetTypeInfoCount(&This->node.dispex.IDispatchEx_iface, pctinfo);
 132 }
 133
 134 static HRESULT WINAPI domcdata_GetTypeInfo(
 135     IXMLDOMCDATASection *iface,
 136     UINT iTInfo, LCID lcid,
 137     ITypeInfo** ppTInfo )
 138 {
 139     domcdata *This = impl_from_IXMLDOMCDATASection( iface );
 140     return IDispatchEx_GetTypeInfo(&This->node.dispex.IDispatchEx_iface,
 141         iTInfo, lcid, ppTInfo);
 142 }
 143
 144 static HRESULT WINAPI domcdata_GetIDsOfNames(
 145     IXMLDOMCDATASection *iface,
 146     REFIID riid, LPOLESTR* rgszNames,
 147     UINT cNames, LCID lcid, DISPID* rgDispId )
 148 {
 149     domcdata *This = impl_from_IXMLDOMCDATASection( iface );
 150     return IDispatchEx_GetIDsOfNames(&This->node.dispex.IDispatchEx_iface,
 151         riid, rgszNames, cNames, lcid, rgDispId);
 152 }
 153
 154 static HRESULT WINAPI domcdata_Invoke(
 155     IXMLDOMCDATASection *iface,
 156     DISPID dispIdMember, REFIID riid, LCID lcid,
 157     WORD wFlags, DISPPARAMS* pDispParams, VARIANT* pVarResult,
 158     EXCEPINFO* pExcepInfo, UINT* puArgErr )
 159 {
 160     domcdata *This = impl_from_IXMLDOMCDATASection( iface );
 161     return IDispatchEx_Invoke(&This->node.dispex.IDispatchEx_iface,
 162         dispIdMember, riid, lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
 163 }
 164
 165 static HRESULT WINAPI domcdata_get_nodeName(
 166     IXMLDOMCDATASection *iface,
 167     BSTR* p )
 168 {
 169     domcdata *This = impl_from_IXMLDOMCDATASection( iface );
 170
 171     static const WCHAR cdata_sectionW[] =
 172         {'#','c','d','a','t','a','-','s','e','c','t','i','o','n',0};
 173
 174     TRACE("(%p)->(%p)\n", This, p);
 175
 176     return return_bstr(cdata_sectionW, p);
 177 }
 178
 179 static HRESULT WINAPI domcdata_get_nodeValue(
 180     IXMLDOMCDATASection *iface,
 181     VARIANT* value)
 182 {
 183     domcdata *This = impl_from_IXMLDOMCDATASection( iface );
 184
 185     TRACE("(%p)->(%p)\n", This, value);
 186
 187     return node_get_content(&This->node, value);
 188 }
 189
 190 static HRESULT WINAPI domcdata_put_nodeValue(
 191     IXMLDOMCDATASection *iface,
 192     VARIANT value)
 193 {
 194     domcdata *This = impl_from_IXMLDOMCDATASection( iface );
 195
 196     TRACE("(%p)->(%s)\n", This, debugstr_variant(&value));
 197
 198     return node_put_value(&This->node, &value);
 199 }
 200
 201 static HRESULT WINAPI domcdata_get_nodeType(
 202     IXMLDOMCDATASection *iface,
 203     DOMNodeType* domNodeType )
 204 {
 205     domcdata *This = impl_from_IXMLDOMCDATASection( iface );
 206
 207     TRACE("(%p)->(%p)\n", This, domNodeType);
 208
 209     *domNodeType = NODE_CDATA_SECTION;
 210     return S_OK;
 211 }
 212
 213 static HRESULT WINAPI domcdata_get_parentNode(
 214     IXMLDOMCDATASection *iface,
 215     IXMLDOMNode** parent )
 216 {
 217     domcdata *This = impl_from_IXMLDOMCDATASection( iface );
 218
 219     TRACE("(%p)->(%p)\n", This, parent);
 220
 221     return node_get_parent(&This->node, parent);
 222 }
 223
 224 static HRESULT WINAPI domcdata_get_childNodes(
 225     IXMLDOMCDATASection *iface,
 226     IXMLDOMNodeList** outList)
 227 {
 228     domcdata *This = impl_from_IXMLDOMCDATASection( iface );
 229
 230     TRACE("(%p)->(%p)\n", This, outList);
 231
 232     return node_get_child_nodes(&This->node, outList);
 233 }
 234
 235 static HRESULT WINAPI domcdata_get_firstChild(
 236     IXMLDOMCDATASection *iface,
 237     IXMLDOMNode** domNode)
 238 {
 239     domcdata *This = impl_from_IXMLDOMCDATASection( iface );
 240
 241     TRACE("(%p)->(%p)\n", This, domNode);
 242
 243     return return_null_node(domNode);
 244 }
 245
 246 static HRESULT WINAPI domcdata_get_lastChild(
 247     IXMLDOMCDATASection *iface,
 248     IXMLDOMNode** domNode)
 249 {
 250     domcdata *This = impl_from_IXMLDOMCDATASection( iface );
 251
 252     TRACE("(%p)->(%p)\n", This, domNode);
 253
 254     return return_null_node(domNode);
 255 }
 256
 257 static HRESULT WINAPI domcdata_get_previousSibling(
 258     IXMLDOMCDATASection *iface,
 259     IXMLDOMNode** domNode)
 260 {
 261     domcdata *This = impl_from_IXMLDOMCDATASection( iface );
 262
 263     TRACE("(%p)->(%p)\n", This, domNode);
 264
 265     return node_get_previous_sibling(&This->node, domNode);
 266 }
 267
 268 static HRESULT WINAPI domcdata_get_nextSibling(
 269     IXMLDOMCDATASection *iface,
 270     IXMLDOMNode** domNode)
 271 {
 272     domcdata *This = impl_from_IXMLDOMCDATASection( iface );
 273
 274     TRACE("(%p)->(%p)\n", This, domNode);
 275
 276     return node_get_next_sibling(&This->node, domNode);
 277 }
 278
 279 static HRESULT WINAPI domcdata_get_attributes(
 280     IXMLDOMCDATASection *iface,
 281     IXMLDOMNamedNodeMap** attributeMap)
 282 {
 283     domcdata *This = impl_from_IXMLDOMCDATASection( iface );
 284
 285     TRACE("(%p)->(%p)\n", This, attributeMap);
 286
 287     return return_null_ptr((void**)attributeMap);
 288 }
 289
 290 static HRESULT WINAPI domcdata_insertBefore(
 291     IXMLDOMCDATASection *iface,
 292     IXMLDOMNode* newNode, VARIANT refChild,
 293     IXMLDOMNode** outOldNode)
 294 {
 295     domcdata *This = impl_from_IXMLDOMCDATASection( iface );
 296     TRACE("(%p)->(%p %s %p)\n", This, newNode, debugstr_variant(&refChild), outOldNode);
 297     if (outOldNode) *outOldNode = NULL;
 298     return E_FAIL;
 299 }
 300
 301 static HRESULT WINAPI domcdata_replaceChild(
 302     IXMLDOMCDATASection *iface,
 303     IXMLDOMNode* newNode,
 304     IXMLDOMNode* oldNode,
 305     IXMLDOMNode** outOldNode)
 306 {
 307     domcdata *This = impl_from_IXMLDOMCDATASection( iface );
 308     TRACE("(%p)->(%p %p %p)\n", This, newNode, oldNode, outOldNode);
 309     if (outOldNode) *outOldNode = NULL;
 310     return E_FAIL;
 311 }
 312
 313 static HRESULT WINAPI domcdata_removeChild(
 314     IXMLDOMCDATASection *iface,
 315     IXMLDOMNode *child, IXMLDOMNode **oldChild)
 316 {
 317     domcdata *This = impl_from_IXMLDOMCDATASection( iface );
 318     TRACE("(%p)->(%p %p)\n", This, child, oldChild);
 319     if (oldChild) *oldChild = NULL;
 320     return E_FAIL;
 321 }
 322
 323 static HRESULT WINAPI domcdata_appendChild(
 324     IXMLDOMCDATASection *iface,
 325     IXMLDOMNode *child, IXMLDOMNode **outChild)
 326 {
 327     domcdata *This = impl_from_IXMLDOMCDATASection( iface );
 328     TRACE("(%p)->(%p %p)\n", This, child, outChild);
 329     if (outChild) *outChild = NULL;
 330     return E_FAIL;
 331 }
 332
 333 static HRESULT WINAPI domcdata_hasChildNodes(
 334     IXMLDOMCDATASection *iface,
 335     VARIANT_BOOL *ret)
 336 {
 337     domcdata *This = impl_from_IXMLDOMCDATASection( iface );
 338     TRACE("(%p)->(%p)\n", This, ret);
 339     return node_has_childnodes(&This->node, ret);
 340 }
 341
 342 static HRESULT WINAPI domcdata_get_ownerDocument(
 343     IXMLDOMCDATASection *iface,
 344     IXMLDOMDocument    **doc)
 345 {
 346     domcdata *This = impl_from_IXMLDOMCDATASection( iface );
 347     TRACE("(%p)->(%p)\n", This, doc);
 348     return node_get_owner_doc(&This->node, doc);
 349 }
 350
 351 static HRESULT WINAPI domcdata_cloneNode(
 352     IXMLDOMCDATASection *iface,
 353     VARIANT_BOOL deep, IXMLDOMNode** outNode)
 354 {
 355     domcdata *This = impl_from_IXMLDOMCDATASection( iface );
 356     TRACE("(%p)->(%d %p)\n", This, deep, outNode);
 357     return node_clone( &This->node, deep, outNode );
 358 }
 359
 360 static HRESULT WINAPI domcdata_get_nodeTypeString(
 361     IXMLDOMCDATASection *iface,
 362     BSTR* p)
 363 {
 364     domcdata *This = impl_from_IXMLDOMCDATASection( iface );
 365     static const WCHAR cdatasectionW[] = {'c','d','a','t','a','s','e','c','t','i','o','n',0};
 366
 367     TRACE("(%p)->(%p)\n", This, p);
 368
 369     return return_bstr(cdatasectionW, p);
 370 }
 371
 372 static HRESULT WINAPI domcdata_get_text(
 373     IXMLDOMCDATASection *iface,
 374     BSTR* p)
 375 {
 376     domcdata *This = impl_from_IXMLDOMCDATASection( iface );
 377     TRACE("(%p)->(%p)\n", This, p);
 378     return node_get_text(&This->node, p);
 379 }
 380
 381 static HRESULT WINAPI domcdata_put_text(
 382     IXMLDOMCDATASection *iface,
 383     BSTR p)
 384 {
 385     domcdata *This = impl_from_IXMLDOMCDATASection( iface );
 386     TRACE("(%p)->(%s)\n", This, debugstr_w(p));
 387     return node_put_text( &This->node, p );
 388 }
 389
 390 static HRESULT WINAPI domcdata_get_specified(
 391     IXMLDOMCDATASection *iface,
 392     VARIANT_BOOL* isSpecified)
 393 {
 394     domcdata *This = impl_from_IXMLDOMCDATASection( iface );
 395     FIXME("(%p)->(%p) stub!\n", This, isSpecified);
 396     *isSpecified = VARIANT_TRUE;
 397     return S_OK;
 398 }
 399
 400 static HRESULT WINAPI domcdata_get_definition(
 401     IXMLDOMCDATASection *iface,
 402     IXMLDOMNode** definitionNode)
 403 {
 404     domcdata *This = impl_from_IXMLDOMCDATASection( iface );
 405     FIXME("(%p)->(%p)\n", This, definitionNode);
 406     return E_NOTIMPL;
 407 }
 408
 409 static HRESULT WINAPI domcdata_get_nodeTypedValue(
 410     IXMLDOMCDATASection *iface,
 411     VARIANT* v)
 412 {
 413     domcdata *This = impl_from_IXMLDOMCDATASection( iface );
 414     TRACE("(%p)->(%p)\n", This, v);
 415     return node_get_content(&This->node, v);
 416 }
 417
 418 static HRESULT WINAPI domcdata_put_nodeTypedValue(
 419     IXMLDOMCDATASection *iface,
 420     VARIANT typedValue)
 421 {
 422     domcdata *This = impl_from_IXMLDOMCDATASection( iface );
 423     FIXME("(%p)->(%s)\n", This, debugstr_variant(&typedValue));
 424     return E_NOTIMPL;
 425 }
 426
 427 static HRESULT WINAPI domcdata_get_dataType(
 428     IXMLDOMCDATASection *iface,
 429     VARIANT* typename)
 430 {
 431     domcdata *This = impl_from_IXMLDOMCDATASection( iface );
 432     TRACE("(%p)->(%p)\n", This, typename);
 433     return return_null_var( typename );
 434 }
 435
 436 static HRESULT WINAPI domcdata_put_dataType(
 437     IXMLDOMCDATASection *iface,
 438     BSTR p)
 439 {
 440     domcdata *This = impl_from_IXMLDOMCDATASection( iface );
 441
 442     TRACE("(%p)->(%s)\n", This, debugstr_w(p));
 443
 444     if(!p)
 445         return E_INVALIDARG;
 446
 447     return E_FAIL;
 448 }
 449
 450 static HRESULT WINAPI domcdata_get_xml(
 451     IXMLDOMCDATASection *iface,
 452     BSTR* p)
 453 {
 454     domcdata *This = impl_from_IXMLDOMCDATASection( iface );
 455
 456     TRACE("(%p)->(%p)\n", This, p);
 457
 458     return node_get_xml(&This->node, FALSE, p);
 459 }
 460
 461 static HRESULT WINAPI domcdata_transformNode(
 462     IXMLDOMCDATASection *iface,
 463     IXMLDOMNode *node, BSTR *p)
 464 {
 465     domcdata *This = impl_from_IXMLDOMCDATASection( iface );
 466     TRACE("(%p)->(%p %p)\n", This, node, p);
 467     return node_transform_node(&This->node, node, p);
 468 }
 469
 470 static HRESULT WINAPI domcdata_selectNodes(
 471     IXMLDOMCDATASection *iface,
 472     BSTR p, IXMLDOMNodeList** outList)
 473 {
 474     domcdata *This = impl_from_IXMLDOMCDATASection( iface );
 475     TRACE("(%p)->(%s %p)\n", This, debugstr_w(p), outList);
 476     return node_select_nodes(&This->node, p, outList);
 477 }
 478
 479 static HRESULT WINAPI domcdata_selectSingleNode(
 480     IXMLDOMCDATASection *iface,
 481     BSTR p, IXMLDOMNode** outNode)
 482 {
 483     domcdata *This = impl_from_IXMLDOMCDATASection( iface );
 484     TRACE("(%p)->(%s %p)\n", This, debugstr_w(p), outNode);
 485     return node_select_singlenode(&This->node, p, outNode);
 486 }
 487
 488 static HRESULT WINAPI domcdata_get_parsed(
 489     IXMLDOMCDATASection *iface,
 490     VARIANT_BOOL* isParsed)
 491 {
 492     domcdata *This = impl_from_IXMLDOMCDATASection( iface );
 493     FIXME("(%p)->(%p) stub!\n", This, isParsed);
 494     *isParsed = VARIANT_TRUE;
 495     return S_OK;
 496 }
 497
 498 static HRESULT WINAPI domcdata_get_namespaceURI(
 499     IXMLDOMCDATASection *iface,
 500     BSTR* p)
 501 {
 502     domcdata *This = impl_from_IXMLDOMCDATASection( iface );
 503     TRACE("(%p)->(%p)\n", This, p);
 504     return node_get_namespaceURI(&This->node, p);
 505 }
 506
 507 static HRESULT WINAPI domcdata_get_prefix(
 508     IXMLDOMCDATASection *iface,
 509     BSTR* prefix)
 510 {
 511     domcdata *This = impl_from_IXMLDOMCDATASection( iface );
 512     TRACE("(%p)->(%p)\n", This, prefix);
 513     return return_null_bstr( prefix );
 514 }
 515
 516 static HRESULT WINAPI domcdata_get_baseName(
 517     IXMLDOMCDATASection *iface,
 518     BSTR* name)
 519 {
 520     domcdata *This = impl_from_IXMLDOMCDATASection( iface );
 521     FIXME("(%p)->(%p): needs test\n", This, name);
 522     return return_null_bstr( name );
 523 }
 524
 525 static HRESULT WINAPI domcdata_transformNodeToObject(
 526     IXMLDOMCDATASection *iface,
 527     IXMLDOMNode* domNode, VARIANT var1)
 528 {
 529     domcdata *This = impl_from_IXMLDOMCDATASection( iface );
 530     FIXME("(%p)->(%p %s)\n", This, domNode, debugstr_variant(&var1));
 531     return E_NOTIMPL;
 532 }
 533
 534 static HRESULT WINAPI domcdata_get_data(
 535     IXMLDOMCDATASection *iface,
 536     BSTR *p)
 537 {
 538     HRESULT hr;
 539     VARIANT vRet;
 540
 541     if(!p)
 542         return E_INVALIDARG;
 543
 544     hr = IXMLDOMCDATASection_get_nodeValue( iface, &vRet );
 545     if(hr == S_OK)
 546     {
 547         *p = V_BSTR(&vRet);
 548     }
 549
 550     return hr;
 551 }
 552
 553 static HRESULT WINAPI domcdata_put_data(
 554     IXMLDOMCDATASection *iface,
 555     BSTR data)
 556 {
 557     domcdata *This = impl_from_IXMLDOMCDATASection( iface );
 558     TRACE("(%p)->(%s)\n", This, debugstr_w(data));
 559     return node_set_content(&This->node, data);
 560 }
 561
 562 static HRESULT WINAPI domcdata_get_length(
 563     IXMLDOMCDATASection *iface,
 564     LONG *len)
 565 {
 566     domcdata *This = impl_from_IXMLDOMCDATASection( iface );
 567     HRESULT hr;
 568     BSTR data;
 569
 570     TRACE("(%p)->(%p)\n", This, len);
 571
 572     if(!len)
 573         return E_INVALIDARG;
 574
 575     hr = IXMLDOMCDATASection_get_data(iface, &data);
 576     if(hr == S_OK)
 577     {
 578         *len = SysStringLen(data);
 579         SysFreeString(data);
 580     }
 581
 582     return S_OK;
 583 }
 584
 585 static HRESULT WINAPI domcdata_substringData(
 586     IXMLDOMCDATASection *iface,
 587     LONG offset, LONG count, BSTR *p)
 588 {
 589     domcdata *This = impl_from_IXMLDOMCDATASection( iface );
 590     HRESULT hr;
 591     BSTR data;
 592
 593     TRACE("(%p)->(%d %d %p)\n", This, offset, count, p);
 594
 595     if(!p)
 596         return E_INVALIDARG;
 597
 598     *p = NULL;
 599     if(offset < 0 || count < 0)
 600         return E_INVALIDARG;
 601
 602     if(count == 0)
 603         return S_FALSE;
 604
 605     hr = IXMLDOMCDATASection_get_data(iface, &data);
 606     if(hr == S_OK)
 607     {
 608         LONG len = SysStringLen(data);
 609
 610         if(offset < len)
 611         {
 612             if(offset + count > len)
 613                 *p = SysAllocString(&data[offset]);
 614             else
 615                 *p = SysAllocStringLen(&data[offset], count);
 616         }
 617         else
 618             hr = S_FALSE;
 619
 620         SysFreeString(data);
 621     }
 622
 623     return hr;
 624 }
 625
 626 static HRESULT WINAPI domcdata_appendData(
 627     IXMLDOMCDATASection *iface,
 628     BSTR p)
 629 {
 630     domcdata *This = impl_from_IXMLDOMCDATASection( iface );
 631     HRESULT hr;
 632     BSTR data;
 633     LONG p_len;
 634
 635     TRACE("(%p)->(%s)\n", This, debugstr_w(p));
 636
 637     /* Nothing to do if NULL or an Empty string passed in. */
 638     if((p_len = SysStringLen(p)) == 0) return S_OK;
 639
 640     hr = IXMLDOMCDATASection_get_data(iface, &data);
 641     if(hr == S_OK)
 642     {
 643         LONG len = SysStringLen(data);
 644         BSTR str = SysAllocStringLen(NULL, p_len + len);
 645
 646         memcpy(str, data, len*sizeof(WCHAR));
 647         memcpy(&str[len], p, p_len*sizeof(WCHAR));
 648         str[len+p_len] = 0;
 649
 650         hr = IXMLDOMCDATASection_put_data(iface, str);
 651
 652         SysFreeString(str);
 653         SysFreeString(data);
 654     }
 655
 656     return hr;
 657 }
 658
 659 static HRESULT WINAPI domcdata_insertData(
 660     IXMLDOMCDATASection *iface,
 661     LONG offset, BSTR p)
 662 {
 663     domcdata *This = impl_from_IXMLDOMCDATASection( iface );
 664     HRESULT hr;
 665     BSTR data;
 666     LONG p_len;
 667
 668     TRACE("(%p)->(%d %s)\n", This, offset, debugstr_w(p));
 669
 670     /* If have a NULL or empty string, don't do anything. */
 671     if((p_len = SysStringLen(p)) == 0)
 672         return S_OK;
 673
 674     if(offset < 0)
 675     {
 676         return E_INVALIDARG;
 677     }
 678
 679     hr = IXMLDOMCDATASection_get_data(iface, &data);
 680     if(hr == S_OK)
 681     {
 682         LONG len = SysStringLen(data);
 683         BSTR str;
 684
 685         if(len < offset)
 686         {
 687             SysFreeString(data);
 688             return E_INVALIDARG;
 689         }
 690
 691         str = SysAllocStringLen(NULL, len + p_len);
 692         /* start part, supplied string and end part */
 693         memcpy(str, data, offset*sizeof(WCHAR));
 694         memcpy(&str[offset], p, p_len*sizeof(WCHAR));
 695         memcpy(&str[offset+p_len], &data[offset], (len-offset)*sizeof(WCHAR));
 696         str[len+p_len] = 0;
 697
 698         hr = IXMLDOMCDATASection_put_data(iface, str);
 699
 700         SysFreeString(str);
 701         SysFreeString(data);
 702     }
 703
 704     return hr;
 705 }
 706
 707 static HRESULT WINAPI domcdata_deleteData(
 708     IXMLDOMCDATASection *iface,
 709     LONG offset, LONG count)
 710 {
 711     domcdata *This = impl_from_IXMLDOMCDATASection( iface );
 712     HRESULT hr;
 713     LONG len = -1;
 714     BSTR str;
 715
 716     TRACE("(%p)->(%d %d)\n", This, offset, count);
 717
 718     hr = IXMLDOMCDATASection_get_length(iface, &len);
 719     if(hr != S_OK) return hr;
 720
 721     if((offset < 0) || (offset > len) || (count < 0))
 722         return E_INVALIDARG;
 723
 724     if(len == 0) return S_OK;
 725
 726     /* cutting start or end */
 727     if((offset == 0) || ((count + offset) >= len))
 728     {
 729         if(offset == 0)
 730             IXMLDOMCDATASection_substringData(iface, count, len - count, &str);
 731         else
 732             IXMLDOMCDATASection_substringData(iface, 0, offset, &str);
 733         hr = IXMLDOMCDATASection_put_data(iface, str);
 734     }
 735     else
 736     /* cutting from the inside */
 737     {
 738         BSTR str_end;
 739
 740         IXMLDOMCDATASection_substringData(iface, 0, offset, &str);
 741         IXMLDOMCDATASection_substringData(iface, offset + count, len - count, &str_end);
 742
 743         hr = IXMLDOMCDATASection_put_data(iface, str);
 744         if(hr == S_OK)
 745             hr = IXMLDOMCDATASection_appendData(iface, str_end);
 746
 747         SysFreeString(str_end);
 748     }
 749
 750     SysFreeString(str);
 751
 752     return hr;
 753 }
 754
 755 static HRESULT WINAPI domcdata_replaceData(
 756     IXMLDOMCDATASection *iface,
 757     LONG offset, LONG count, BSTR p)
 758 {
 759     domcdata *This = impl_from_IXMLDOMCDATASection( iface );
 760     HRESULT hr;
 761
 762     TRACE("(%p)->(%d %d %s)\n", This, offset, count, debugstr_w(p));
 763
 764     hr = IXMLDOMCDATASection_deleteData(iface, offset, count);
 765
 766     if (hr == S_OK)
 767        hr = IXMLDOMCDATASection_insertData(iface, offset, p);
 768
 769     return hr;
 770 }
 771
 772 static HRESULT WINAPI domcdata_splitText(
 773     IXMLDOMCDATASection *iface,
 774     LONG offset, IXMLDOMText **txtNode)
 775 {
 776     domcdata *This = impl_from_IXMLDOMCDATASection( iface );
 777     IXMLDOMDocument *doc;
 778     LONG length = 0;
 779     HRESULT hr;
 780
 781     TRACE("(%p)->(%d %p)\n", This, offset, txtNode);
 782
 783     if (!txtNode || offset < 0) return E_INVALIDARG;
 784
 785     *txtNode = NULL;
 786
 787     IXMLDOMCDATASection_get_length(iface, &length);
 788
 789     if (offset > length) return E_INVALIDARG;
 790     if (offset == length) return S_FALSE;
 791
 792     hr = IXMLDOMCDATASection_get_ownerDocument(iface, &doc);
 793     if (hr == S_OK)
 794     {
 795         BSTR data;
 796
 797         hr = IXMLDOMCDATASection_substringData(iface, offset, length - offset, &data);
 798         if (hr == S_OK)
 799         {
 800             hr = IXMLDOMDocument_createTextNode(doc, data, txtNode);
 801             if (hr == S_OK)
 802             {
 803                 IXMLDOMNode *parent;
 804
 805                 hr = IXMLDOMCDATASection_get_parentNode(iface, &parent);
 806                 if (hr == S_OK)
 807                 {
 808                     IXMLDOMCDATASection_deleteData(iface, 0, offset);
 809                     hr = IXMLDOMNode_appendChild(parent, (IXMLDOMNode*)*txtNode, NULL);
 810                     IXMLDOMNode_Release(parent);
 811                 }
 812             }
 813             SysFreeString(data);
 814         }
 815         IXMLDOMDocument_Release(doc);
 816     }
 817
 818     return hr;
 819 }
 820
 821 static const struct IXMLDOMCDATASectionVtbl domcdata_vtbl =
 822 {
 823     domcdata_QueryInterface,
 824     domcdata_AddRef,
 825     domcdata_Release,
 826     domcdata_GetTypeInfoCount,
 827     domcdata_GetTypeInfo,
 828     domcdata_GetIDsOfNames,
 829     domcdata_Invoke,
 830     domcdata_get_nodeName,
 831     domcdata_get_nodeValue,
 832     domcdata_put_nodeValue,
 833     domcdata_get_nodeType,
 834     domcdata_get_parentNode,
 835     domcdata_get_childNodes,
 836     domcdata_get_firstChild,
 837     domcdata_get_lastChild,
 838     domcdata_get_previousSibling,
 839     domcdata_get_nextSibling,
 840     domcdata_get_attributes,
 841     domcdata_insertBefore,
 842     domcdata_replaceChild,
 843     domcdata_removeChild,
 844     domcdata_appendChild,
 845     domcdata_hasChildNodes,
 846     domcdata_get_ownerDocument,
 847     domcdata_cloneNode,
 848     domcdata_get_nodeTypeString,
 849     domcdata_get_text,
 850     domcdata_put_text,
 851     domcdata_get_specified,
 852     domcdata_get_definition,
 853     domcdata_get_nodeTypedValue,
 854     domcdata_put_nodeTypedValue,
 855     domcdata_get_dataType,
 856     domcdata_put_dataType,
 857     domcdata_get_xml,
 858     domcdata_transformNode,
 859     domcdata_selectNodes,
 860     domcdata_selectSingleNode,
 861     domcdata_get_parsed,
 862     domcdata_get_namespaceURI,
 863     domcdata_get_prefix,
 864     domcdata_get_baseName,
 865     domcdata_transformNodeToObject,
 866     domcdata_get_data,
 867     domcdata_put_data,
 868     domcdata_get_length,
 869     domcdata_substringData,
 870     domcdata_appendData,
 871     domcdata_insertData,
 872     domcdata_deleteData,
 873     domcdata_replaceData,
 874     domcdata_splitText
 875 };
 876
 877 static const tid_t domcdata_iface_tids[] = {
 878     IXMLDOMCDATASection_tid,
 879     0
 880 };
 881
 882 static dispex_static_data_t domcdata_dispex = {
 883     NULL,
 884     IXMLDOMCDATASection_tid,
 885     NULL,
 886     domcdata_iface_tids
 887 };
 888
 889 IUnknown* create_cdata( xmlNodePtr text )
 890 {
 891     domcdata *This;
 892
 893     This = heap_alloc( sizeof *This );
 894     if ( !This )
 895         return NULL;
 896
 897     This->IXMLDOMCDATASection_iface.lpVtbl = &domcdata_vtbl;
 898     This->ref = 1;
 899
 900     init_xmlnode(&This->node, text, (IXMLDOMNode*)&This->IXMLDOMCDATASection_iface, &domcdata_dispex);
 901
 902     return (IUnknown*)&This->IXMLDOMCDATASection_iface;
 903 }
 904
 905 #endif