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