git.oblomov.eu Git - wine/blob - dlls/msxml3/element.c

   1 /*
   2  *    DOM Document implementation
   3  *
   4  * Copyright 2005 Mike McCormack
   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 "winnls.h"
  35 #include "ole2.h"
  36 #include "msxml6.h"
  37
  38 #include "msxml_private.h"
  39
  40 #include "wine/debug.h"
  41
  42 WINE_DEFAULT_DEBUG_CHANNEL(msxml);
  43
  44 #ifdef HAVE_LIBXML2
  45
  46 static const xmlChar DT_prefix[] = "dt";
  47 static const xmlChar DT_nsURI[] = "urn:schemas-microsoft-com:datatypes";
  48
  49 typedef struct _domelem
  50 {
  51     xmlnode node;
  52     IXMLDOMElement IXMLDOMElement_iface;
  53     LONG ref;
  54 } domelem;
  55
  56 static inline domelem *impl_from_IXMLDOMElement( IXMLDOMElement *iface )
  57 {
  58     return CONTAINING_RECORD(iface, domelem, IXMLDOMElement_iface);
  59 }
  60
  61 static inline xmlNodePtr get_element( const domelem *This )
  62 {
  63     return This->node.node;
  64 }
  65
  66 static HRESULT WINAPI domelem_QueryInterface(
  67     IXMLDOMElement *iface,
  68     REFIID riid,
  69     void** ppvObject )
  70 {
  71     domelem *This = impl_from_IXMLDOMElement( iface );
  72
  73     TRACE("(%p)->(%s %p)\n", This, debugstr_guid(riid), ppvObject);
  74
  75     if ( IsEqualGUID( riid, &IID_IXMLDOMElement ) ||
  76          IsEqualGUID( riid, &IID_IXMLDOMNode ) ||
  77          IsEqualGUID( riid, &IID_IDispatch ) ||
  78          IsEqualGUID( riid, &IID_IUnknown ) )
  79     {
  80         *ppvObject = &This->IXMLDOMElement_iface;
  81     }
  82     else if(node_query_interface(&This->node, riid, ppvObject))
  83     {
  84         return *ppvObject ? S_OK : E_NOINTERFACE;
  85     }
  86     else
  87     {
  88         FIXME("interface %s not implemented\n", debugstr_guid(riid));
  89         return E_NOINTERFACE;
  90     }
  91
  92     IUnknown_AddRef( (IUnknown*)*ppvObject );
  93     return S_OK;
  94 }
  95
  96 static ULONG WINAPI domelem_AddRef(
  97     IXMLDOMElement *iface )
  98 {
  99     domelem *This = impl_from_IXMLDOMElement( iface );
 100     LONG ref = InterlockedIncrement(&This->ref);
 101
 102     TRACE("(%p) ref=%d\n", This, ref);
 103
 104     return ref;
 105 }
 106
 107 static ULONG WINAPI domelem_Release(
 108     IXMLDOMElement *iface )
 109 {
 110     domelem *This = impl_from_IXMLDOMElement( iface );
 111     ULONG ref = InterlockedDecrement(&This->ref);
 112
 113     TRACE("(%p) ref=%d\n", This, ref);
 114
 115     if(!ref) {
 116         destroy_xmlnode(&This->node);
 117         heap_free(This);
 118     }
 119
 120     return ref;
 121 }
 122
 123 static HRESULT WINAPI domelem_GetTypeInfoCount(
 124     IXMLDOMElement *iface,
 125     UINT* pctinfo )
 126 {
 127     domelem *This = impl_from_IXMLDOMElement( iface );
 128
 129     TRACE("(%p)->(%p)\n", This, pctinfo);
 130
 131     *pctinfo = 1;
 132
 133     return S_OK;
 134 }
 135
 136 static HRESULT WINAPI domelem_GetTypeInfo(
 137     IXMLDOMElement *iface,
 138     UINT iTInfo, LCID lcid,
 139     ITypeInfo** ppTInfo )
 140 {
 141     domelem *This = impl_from_IXMLDOMElement( iface );
 142     HRESULT hr;
 143
 144     TRACE("(%p)->(%u %u %p)\n", This, iTInfo, lcid, ppTInfo);
 145
 146     hr = get_typeinfo(IXMLDOMElement_tid, ppTInfo);
 147
 148     return hr;
 149 }
 150
 151 static HRESULT WINAPI domelem_GetIDsOfNames(
 152     IXMLDOMElement *iface,
 153     REFIID riid, LPOLESTR* rgszNames,
 154     UINT cNames, LCID lcid, DISPID* rgDispId )
 155 {
 156     domelem *This = impl_from_IXMLDOMElement( iface );
 157     ITypeInfo *typeinfo;
 158     HRESULT hr;
 159
 160     TRACE("(%p)->(%s %p %u %u %p)\n", This, debugstr_guid(riid), rgszNames, cNames,
 161           lcid, rgDispId);
 162
 163     if(!rgszNames || cNames == 0 || !rgDispId)
 164         return E_INVALIDARG;
 165
 166     hr = get_typeinfo(IXMLDOMElement_tid, &typeinfo);
 167     if(SUCCEEDED(hr))
 168     {
 169         hr = ITypeInfo_GetIDsOfNames(typeinfo, rgszNames, cNames, rgDispId);
 170         ITypeInfo_Release(typeinfo);
 171     }
 172
 173     return hr;
 174 }
 175
 176 static HRESULT WINAPI domelem_Invoke(
 177     IXMLDOMElement *iface,
 178     DISPID dispIdMember, REFIID riid, LCID lcid,
 179     WORD wFlags, DISPPARAMS* pDispParams, VARIANT* pVarResult,
 180     EXCEPINFO* pExcepInfo, UINT* puArgErr )
 181 {
 182     domelem *This = impl_from_IXMLDOMElement( iface );
 183     ITypeInfo *typeinfo;
 184     HRESULT hr;
 185
 186     TRACE("(%p)->(%d %s %d %d %p %p %p %p)\n", This, dispIdMember, debugstr_guid(riid),
 187           lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
 188
 189     hr = get_typeinfo(IXMLDOMElement_tid, &typeinfo);
 190     if(SUCCEEDED(hr))
 191     {
 192         hr = ITypeInfo_Invoke(typeinfo, &This->IXMLDOMElement_iface, dispIdMember, wFlags,
 193                 pDispParams, pVarResult, pExcepInfo, puArgErr);
 194         ITypeInfo_Release(typeinfo);
 195     }
 196
 197     return hr;
 198 }
 199
 200 static HRESULT WINAPI domelem_get_nodeName(
 201     IXMLDOMElement *iface,
 202     BSTR* p )
 203 {
 204     domelem *This = impl_from_IXMLDOMElement( iface );
 205
 206     TRACE("(%p)->(%p)\n", This, p);
 207
 208     return node_get_nodeName(&This->node, p);
 209 }
 210
 211 static HRESULT WINAPI domelem_get_nodeValue(
 212     IXMLDOMElement *iface,
 213     VARIANT* value)
 214 {
 215     domelem *This = impl_from_IXMLDOMElement( iface );
 216
 217     TRACE("(%p)->(%p)\n", This, value);
 218
 219     if(!value)
 220         return E_INVALIDARG;
 221
 222     V_VT(value) = VT_NULL;
 223     V_BSTR(value) = NULL; /* tests show that we should do this */
 224     return S_FALSE;
 225 }
 226
 227 static HRESULT WINAPI domelem_put_nodeValue(
 228     IXMLDOMElement *iface,
 229     VARIANT value)
 230 {
 231     domelem *This = impl_from_IXMLDOMElement( iface );
 232     TRACE("(%p)->(%s)\n", This, debugstr_variant(&value));
 233     return E_FAIL;
 234 }
 235
 236 static HRESULT WINAPI domelem_get_nodeType(
 237     IXMLDOMElement *iface,
 238     DOMNodeType* domNodeType )
 239 {
 240     domelem *This = impl_from_IXMLDOMElement( iface );
 241
 242     TRACE("(%p)->(%p)\n", This, domNodeType);
 243
 244     *domNodeType = NODE_ELEMENT;
 245     return S_OK;
 246 }
 247
 248 static HRESULT WINAPI domelem_get_parentNode(
 249     IXMLDOMElement *iface,
 250     IXMLDOMNode** parent )
 251 {
 252     domelem *This = impl_from_IXMLDOMElement( iface );
 253
 254     TRACE("(%p)->(%p)\n", This, parent);
 255
 256     return node_get_parent(&This->node, parent);
 257 }
 258
 259 static HRESULT WINAPI domelem_get_childNodes(
 260     IXMLDOMElement *iface,
 261     IXMLDOMNodeList** outList)
 262 {
 263     domelem *This = impl_from_IXMLDOMElement( iface );
 264
 265     TRACE("(%p)->(%p)\n", This, outList);
 266
 267     return node_get_child_nodes(&This->node, outList);
 268 }
 269
 270 static HRESULT WINAPI domelem_get_firstChild(
 271     IXMLDOMElement *iface,
 272     IXMLDOMNode** domNode)
 273 {
 274     domelem *This = impl_from_IXMLDOMElement( iface );
 275
 276     TRACE("(%p)->(%p)\n", This, domNode);
 277
 278     return node_get_first_child(&This->node, domNode);
 279 }
 280
 281 static HRESULT WINAPI domelem_get_lastChild(
 282     IXMLDOMElement *iface,
 283     IXMLDOMNode** domNode)
 284 {
 285     domelem *This = impl_from_IXMLDOMElement( iface );
 286
 287     TRACE("(%p)->(%p)\n", This, domNode);
 288
 289     return node_get_last_child(&This->node, domNode);
 290 }
 291
 292 static HRESULT WINAPI domelem_get_previousSibling(
 293     IXMLDOMElement *iface,
 294     IXMLDOMNode** domNode)
 295 {
 296     domelem *This = impl_from_IXMLDOMElement( iface );
 297
 298     TRACE("(%p)->(%p)\n", This, domNode);
 299
 300     return node_get_previous_sibling(&This->node, domNode);
 301 }
 302
 303 static HRESULT WINAPI domelem_get_nextSibling(
 304     IXMLDOMElement *iface,
 305     IXMLDOMNode** domNode)
 306 {
 307     domelem *This = impl_from_IXMLDOMElement( iface );
 308
 309     TRACE("(%p)->(%p)\n", This, domNode);
 310
 311     return node_get_next_sibling(&This->node, domNode);
 312 }
 313
 314 static HRESULT WINAPI domelem_get_attributes(
 315     IXMLDOMElement *iface,
 316     IXMLDOMNamedNodeMap** attributeMap)
 317 {
 318     domelem *This = impl_from_IXMLDOMElement( iface );
 319
 320     TRACE("(%p)->(%p)\n", This, attributeMap);
 321
 322     *attributeMap = create_nodemap((IXMLDOMNode*)&This->IXMLDOMElement_iface);
 323     return S_OK;
 324 }
 325
 326 static HRESULT WINAPI domelem_insertBefore(
 327     IXMLDOMElement *iface,
 328     IXMLDOMNode* newNode, VARIANT refChild,
 329     IXMLDOMNode** outOldNode)
 330 {
 331     domelem *This = impl_from_IXMLDOMElement( iface );
 332
 333     TRACE("(%p)->(%p %s %p)\n", This, newNode, debugstr_variant(&refChild), outOldNode);
 334
 335     return node_insert_before(&This->node, newNode, &refChild, outOldNode);
 336 }
 337
 338 static HRESULT WINAPI domelem_replaceChild(
 339     IXMLDOMElement *iface,
 340     IXMLDOMNode* newNode,
 341     IXMLDOMNode* oldNode,
 342     IXMLDOMNode** outOldNode)
 343 {
 344     domelem *This = impl_from_IXMLDOMElement( iface );
 345
 346     TRACE("(%p)->(%p %p %p)\n", This, newNode, oldNode, outOldNode);
 347
 348     return node_replace_child(&This->node, newNode, oldNode, outOldNode);
 349 }
 350
 351 static HRESULT WINAPI domelem_removeChild(
 352     IXMLDOMElement *iface,
 353     IXMLDOMNode *child, IXMLDOMNode **oldChild)
 354 {
 355     domelem *This = impl_from_IXMLDOMElement( iface );
 356     TRACE("(%p)->(%p %p)\n", This, child, oldChild);
 357     return node_remove_child(&This->node, child, oldChild);
 358 }
 359
 360 static HRESULT WINAPI domelem_appendChild(
 361     IXMLDOMElement *iface,
 362     IXMLDOMNode *child, IXMLDOMNode **outChild)
 363 {
 364     domelem *This = impl_from_IXMLDOMElement( iface );
 365     TRACE("(%p)->(%p %p)\n", This, child, outChild);
 366     return node_append_child(&This->node, child, outChild);
 367 }
 368
 369 static HRESULT WINAPI domelem_hasChildNodes(
 370     IXMLDOMElement *iface,
 371     VARIANT_BOOL *ret)
 372 {
 373     domelem *This = impl_from_IXMLDOMElement( iface );
 374     TRACE("(%p)->(%p)\n", This, ret);
 375     return node_has_childnodes(&This->node, ret);
 376 }
 377
 378 static HRESULT WINAPI domelem_get_ownerDocument(
 379     IXMLDOMElement   *iface,
 380     IXMLDOMDocument **doc)
 381 {
 382     domelem *This = impl_from_IXMLDOMElement( iface );
 383     TRACE("(%p)->(%p)\n", This, doc);
 384     return node_get_owner_doc(&This->node, doc);
 385 }
 386
 387 static HRESULT WINAPI domelem_cloneNode(
 388     IXMLDOMElement *iface,
 389     VARIANT_BOOL deep, IXMLDOMNode** outNode)
 390 {
 391     domelem *This = impl_from_IXMLDOMElement( iface );
 392     TRACE("(%p)->(%d %p)\n", This, deep, outNode);
 393     return node_clone( &This->node, deep, outNode );
 394 }
 395
 396 static HRESULT WINAPI domelem_get_nodeTypeString(
 397     IXMLDOMElement *iface,
 398     BSTR* p)
 399 {
 400     domelem *This = impl_from_IXMLDOMElement( iface );
 401     static const WCHAR elementW[] = {'e','l','e','m','e','n','t',0};
 402
 403     TRACE("(%p)->(%p)\n", This, p);
 404
 405     return return_bstr(elementW, p);
 406 }
 407
 408 static HRESULT WINAPI domelem_get_text(
 409     IXMLDOMElement *iface,
 410     BSTR* p)
 411 {
 412     domelem *This = impl_from_IXMLDOMElement( iface );
 413     TRACE("(%p)->(%p)\n", This, p);
 414     return node_get_text(&This->node, p);
 415 }
 416
 417 static HRESULT WINAPI domelem_put_text(
 418     IXMLDOMElement *iface,
 419     BSTR p)
 420 {
 421     domelem *This = impl_from_IXMLDOMElement( iface );
 422     TRACE("(%p)->(%s)\n", This, debugstr_w(p));
 423     return node_put_text( &This->node, p );
 424 }
 425
 426 static HRESULT WINAPI domelem_get_specified(
 427     IXMLDOMElement *iface,
 428     VARIANT_BOOL* isSpecified)
 429 {
 430     domelem *This = impl_from_IXMLDOMElement( iface );
 431     FIXME("(%p)->(%p) stub!\n", This, isSpecified);
 432     *isSpecified = VARIANT_TRUE;
 433     return S_OK;
 434 }
 435
 436 static HRESULT WINAPI domelem_get_definition(
 437     IXMLDOMElement *iface,
 438     IXMLDOMNode** definitionNode)
 439 {
 440     domelem *This = impl_from_IXMLDOMElement( iface );
 441     FIXME("(%p)->(%p)\n", This, definitionNode);
 442     return E_NOTIMPL;
 443 }
 444
 445 static inline BYTE hex_to_byte(xmlChar c)
 446 {
 447     if(c <= '9') return c-'0';
 448     if(c <= 'F') return c-'A'+10;
 449     return c-'a'+10;
 450 }
 451
 452 static inline BYTE base64_to_byte(xmlChar c)
 453 {
 454     if(c == '+') return 62;
 455     if(c == '/') return 63;
 456     if(c <= '9') return c-'0'+52;
 457     if(c <= 'Z') return c-'A';
 458     return c-'a'+26;
 459 }
 460
 461 static inline HRESULT VARIANT_from_DT(XDR_DT dt, xmlChar* str, VARIANT* v)
 462 {
 463     VARIANT src;
 464     HRESULT hr = S_OK;
 465     BOOL handled = FALSE;
 466
 467     VariantInit(&src);
 468
 469     switch (dt)
 470     {
 471     case DT_INVALID:
 472     case DT_STRING:
 473     case DT_NMTOKEN:
 474     case DT_NMTOKENS:
 475     case DT_NUMBER:
 476     case DT_URI:
 477     case DT_UUID:
 478         {
 479             V_VT(v) = VT_BSTR;
 480             V_BSTR(v) = bstr_from_xmlChar(str);
 481
 482             if(!V_BSTR(v))
 483                 return E_OUTOFMEMORY;
 484             handled = TRUE;
 485         }
 486         break;
 487     case DT_DATE:
 488     case DT_DATE_TZ:
 489     case DT_DATETIME:
 490     case DT_DATETIME_TZ:
 491     case DT_TIME:
 492     case DT_TIME_TZ:
 493         {
 494             WCHAR *p, *e;
 495             SYSTEMTIME st;
 496             DOUBLE date = 0.0;
 497
 498             st.wYear = 1899;
 499             st.wMonth = 12;
 500             st.wDay = 30;
 501             st.wDayOfWeek = st.wHour = st.wMinute = st.wSecond = st.wMilliseconds = 0;
 502
 503             V_VT(&src) = VT_BSTR;
 504             V_BSTR(&src) = bstr_from_xmlChar(str);
 505
 506             if(!V_BSTR(&src))
 507                 return E_OUTOFMEMORY;
 508
 509             p = V_BSTR(&src);
 510             e = p + SysStringLen(V_BSTR(&src));
 511
 512             if(p+4<e && *(p+4)=='-') /* parse date (yyyy-mm-dd) */
 513             {
 514                 st.wYear = atoiW(p);
 515                 st.wMonth = atoiW(p+5);
 516                 st.wDay = atoiW(p+8);
 517                 p += 10;
 518
 519                 if(*p == 'T') p++;
 520             }
 521
 522             if(p+2<e && *(p+2)==':') /* parse time (hh:mm:ss.?) */
 523             {
 524                 st.wHour = atoiW(p);
 525                 st.wMinute = atoiW(p+3);
 526                 st.wSecond = atoiW(p+6);
 527                 p += 8;
 528
 529                 if(*p == '.')
 530                 {
 531                     p++;
 532                     while(isdigitW(*p)) p++;
 533                 }
 534             }
 535
 536             SystemTimeToVariantTime(&st, &date);
 537             V_VT(v) = VT_DATE;
 538             V_DATE(v) = date;
 539
 540             if(*p == '+') /* parse timezone offset (+hh:mm) */
 541                 V_DATE(v) += (DOUBLE)atoiW(p+1)/24 + (DOUBLE)atoiW(p+4)/1440;
 542             else if(*p == '-') /* parse timezone offset (-hh:mm) */
 543                 V_DATE(v) -= (DOUBLE)atoiW(p+1)/24 + (DOUBLE)atoiW(p+4)/1440;
 544
 545             VariantClear(&src);
 546             handled = TRUE;
 547         }
 548         break;
 549     case DT_BIN_HEX:
 550         {
 551             SAFEARRAYBOUND sab;
 552             int i, len;
 553
 554             len = xmlStrlen(str)/2;
 555             sab.lLbound = 0;
 556             sab.cElements = len;
 557
 558             V_VT(v) = (VT_ARRAY|VT_UI1);
 559             V_ARRAY(v) = SafeArrayCreate(VT_UI1, 1, &sab);
 560
 561             if(!V_ARRAY(v))
 562                 return E_OUTOFMEMORY;
 563
 564             for(i=0; i<len; i++)
 565                 ((BYTE*)V_ARRAY(v)->pvData)[i] = (hex_to_byte(str[2*i])<<4)
 566                     + hex_to_byte(str[2*i+1]);
 567             handled = TRUE;
 568         }
 569         break;
 570     case DT_BIN_BASE64:
 571         {
 572             SAFEARRAYBOUND sab;
 573             int i, len;
 574
 575             len  = xmlStrlen(str);
 576             if(str[len-2] == '=') i = 2;
 577             else if(str[len-1] == '=') i = 1;
 578             else i = 0;
 579
 580             sab.lLbound = 0;
 581             sab.cElements = len/4*3-i;
 582
 583             V_VT(v) = (VT_ARRAY|VT_UI1);
 584             V_ARRAY(v) = SafeArrayCreate(VT_UI1, 1, &sab);
 585
 586             if(!V_ARRAY(v))
 587                 return E_OUTOFMEMORY;
 588
 589             for(i=0; i<len/4; i++)
 590             {
 591                 ((BYTE*)V_ARRAY(v)->pvData)[3*i] = (base64_to_byte(str[4*i])<<2)
 592                     + (base64_to_byte(str[4*i+1])>>4);
 593                 if(3*i+1 < sab.cElements)
 594                     ((BYTE*)V_ARRAY(v)->pvData)[3*i+1] = (base64_to_byte(str[4*i+1])<<4)
 595                         + (base64_to_byte(str[4*i+2])>>2);
 596                 if(3*i+2 < sab.cElements)
 597                     ((BYTE*)V_ARRAY(v)->pvData)[3*i+2] = (base64_to_byte(str[4*i+2])<<6)
 598                         + base64_to_byte(str[4*i+3]);
 599             }
 600             handled = TRUE;
 601         }
 602         break;
 603     case DT_BOOLEAN:
 604         V_VT(v) = VT_BOOL;
 605         break;
 606     case DT_FIXED_14_4:
 607         V_VT(v) = VT_CY;
 608         break;
 609     case DT_I1:
 610         V_VT(v) = VT_I1;
 611         break;
 612     case DT_I2:
 613         V_VT(v) = VT_I2;
 614         break;
 615     case DT_I4:
 616     case DT_INT:
 617         V_VT(v) = VT_I4;
 618         break;
 619     case DT_I8:
 620         V_VT(v) = VT_I8;
 621         break;
 622     case DT_R4:
 623         V_VT(v) = VT_R4;
 624         break;
 625     case DT_FLOAT:
 626     case DT_R8:
 627         V_VT(v) = VT_R8;
 628         break;
 629     case DT_UI1:
 630         V_VT(v) = VT_UI1;
 631         break;
 632     case DT_UI2:
 633         V_VT(v) = VT_UI2;
 634         break;
 635     case DT_UI4:
 636         V_VT(v) = VT_UI4;
 637         break;
 638     case DT_UI8:
 639         V_VT(v) = VT_UI8;
 640         break;
 641     case DT_CHAR:
 642     case DT_ENTITY:
 643     case DT_ENTITIES:
 644     case DT_ENUMERATION:
 645     case DT_ID:
 646     case DT_IDREF:
 647     case DT_IDREFS:
 648     case DT_NOTATION:
 649         FIXME("need to handle dt:%s\n", dt_to_str(dt));
 650         V_VT(v) = VT_BSTR;
 651         V_BSTR(v) = bstr_from_xmlChar(str);
 652         if (!V_BSTR(v))
 653             return E_OUTOFMEMORY;
 654         handled = TRUE;
 655         break;
 656     }
 657
 658     if (!handled)
 659     {
 660         V_VT(&src) = VT_BSTR;
 661         V_BSTR(&src) = bstr_from_xmlChar(str);
 662
 663         if(!V_BSTR(&src))
 664             return E_OUTOFMEMORY;
 665
 666         hr = VariantChangeTypeEx(v, &src,
 667                 MAKELCID(MAKELANGID(LANG_ENGLISH,SUBLANG_ENGLISH_US),SORT_DEFAULT),0, V_VT(v));
 668         VariantClear(&src);
 669     }
 670     return hr;
 671 }
 672
 673 static HRESULT WINAPI domelem_get_nodeTypedValue(
 674     IXMLDOMElement *iface,
 675     VARIANT* var1)
 676 {
 677     domelem *This = impl_from_IXMLDOMElement( iface );
 678     XDR_DT dt;
 679     xmlChar* content;
 680     HRESULT hr;
 681
 682     TRACE("(%p)->(%p)\n", This, var1);
 683
 684     if(!var1)
 685         return E_INVALIDARG;
 686
 687     V_VT(var1) = VT_NULL;
 688
 689     dt = element_get_dt(get_element(This));
 690     content = xmlNodeGetContent(get_element(This));
 691     hr = VARIANT_from_DT(dt, content, var1);
 692     xmlFree(content);
 693
 694     return hr;
 695 }
 696
 697 static HRESULT WINAPI domelem_put_nodeTypedValue(
 698     IXMLDOMElement *iface,
 699     VARIANT value)
 700 {
 701     domelem *This = impl_from_IXMLDOMElement( iface );
 702     VARIANT type;
 703     HRESULT hr;
 704
 705     TRACE("(%p)->(%s)\n", This, debugstr_variant(&value));
 706
 707     /* for untyped node coerce to BSTR and set */
 708     if (IXMLDOMElement_get_dataType(iface, &type) == S_FALSE)
 709     {
 710         if (V_VT(&value) != VT_BSTR)
 711         {
 712             hr = VariantChangeType(&value, &value, 0, VT_BSTR);
 713             if (hr == S_OK)
 714             {
 715                 hr = node_set_content(&This->node, V_BSTR(&value));
 716                 VariantClear(&value);
 717             }
 718         }
 719         else
 720             hr = node_set_content(&This->node, V_BSTR(&value));
 721     }
 722     else
 723     {
 724         FIXME("not implemented for typed nodes. type %s\n", debugstr_w(V_BSTR(&value)));
 725         VariantClear(&type);
 726         return E_NOTIMPL;
 727     }
 728
 729     return hr;
 730 }
 731
 732 XDR_DT element_get_dt(xmlNodePtr node)
 733 {
 734     XDR_DT dt = DT_INVALID;
 735
 736     TRACE("(%p)\n", node);
 737     if(node->type != XML_ELEMENT_NODE)
 738     {
 739         FIXME("invalid element node\n");
 740         return dt;
 741     }
 742
 743     if (node->ns && xmlStrEqual(node->ns->href, DT_nsURI))
 744     {
 745         dt = str_to_dt(node->name, -1);
 746     }
 747     else
 748     {
 749         xmlChar* pVal = xmlGetNsProp(node, BAD_CAST "dt", DT_nsURI);
 750         if (pVal)
 751         {
 752             dt = str_to_dt(pVal, -1);
 753             xmlFree(pVal);
 754         }
 755         else if (node->doc)
 756         {
 757             IXMLDOMDocument3* doc = (IXMLDOMDocument3*)create_domdoc((xmlNodePtr)node->doc);
 758             if (doc)
 759             {
 760                 VARIANT v;
 761                 VariantInit(&v);
 762
 763                 if (IXMLDOMDocument3_get_schemas(doc, &v) == S_OK &&
 764                     V_VT(&v) == VT_DISPATCH)
 765                 {
 766                     dt = SchemaCache_get_node_dt((IXMLDOMSchemaCollection2*)V_DISPATCH(&v), node);
 767                 }
 768                 VariantClear(&v);
 769                 IXMLDOMDocument3_Release(doc);
 770             }
 771         }
 772     }
 773
 774     TRACE("=> dt:%s\n", dt_to_str(dt));
 775     return dt;
 776 }
 777
 778 static HRESULT WINAPI domelem_get_dataType(
 779     IXMLDOMElement *iface,
 780     VARIANT* typename)
 781 {
 782     domelem *This = impl_from_IXMLDOMElement( iface );
 783     XDR_DT dt;
 784
 785     TRACE("(%p)->(%p)\n", This, typename);
 786
 787     if (!typename)
 788         return E_INVALIDARG;
 789
 790     dt = element_get_dt(get_element(This));
 791     switch (dt)
 792     {
 793         case DT_BIN_BASE64:
 794         case DT_BIN_HEX:
 795         case DT_BOOLEAN:
 796         case DT_CHAR:
 797         case DT_DATE:
 798         case DT_DATE_TZ:
 799         case DT_DATETIME:
 800         case DT_DATETIME_TZ:
 801         case DT_FIXED_14_4:
 802         case DT_FLOAT:
 803         case DT_I1:
 804         case DT_I2:
 805         case DT_I4:
 806         case DT_I8:
 807         case DT_INT:
 808         case DT_NUMBER:
 809         case DT_R4:
 810         case DT_R8:
 811         case DT_TIME:
 812         case DT_TIME_TZ:
 813         case DT_UI1:
 814         case DT_UI2:
 815         case DT_UI4:
 816         case DT_UI8:
 817         case DT_URI:
 818         case DT_UUID:
 819             V_VT(typename) = VT_BSTR;
 820             V_BSTR(typename) = SysAllocString(dt_to_bstr(dt));
 821
 822             if (!V_BSTR(typename))
 823                 return E_OUTOFMEMORY;
 824             break;
 825         default:
 826             /* Other types (DTD equivalents) do not return anything here,
 827              * but the pointer part of the VARIANT is set to NULL */
 828             V_VT(typename) = VT_NULL;
 829             V_BSTR(typename) = NULL;
 830             break;
 831     }
 832     return (V_VT(typename) != VT_NULL) ? S_OK : S_FALSE;
 833 }
 834
 835 static HRESULT WINAPI domelem_put_dataType(
 836     IXMLDOMElement *iface,
 837     BSTR dtName)
 838 {
 839     domelem *This = impl_from_IXMLDOMElement( iface );
 840     HRESULT hr = E_FAIL;
 841     xmlChar *str;
 842     XDR_DT dt;
 843
 844     TRACE("(%p)->(%s)\n", This, debugstr_w(dtName));
 845
 846     if(dtName == NULL)
 847         return E_INVALIDARG;
 848
 849     dt = bstr_to_dt(dtName, -1);
 850
 851     /* An example of this is. The Text in the node needs to be a 0 or 1 for a boolean type.
 852        This applies to changing types (string->bool) or setting a new one
 853      */
 854     str = xmlNodeGetContent(get_element(This));
 855     hr = dt_validate(dt, str);
 856     xmlFree(str);
 857
 858     /* Check all supported types. */
 859     if (hr == S_OK)
 860     {
 861         switch (dt)
 862         {
 863         case DT_BIN_BASE64:
 864         case DT_BIN_HEX:
 865         case DT_BOOLEAN:
 866         case DT_CHAR:
 867         case DT_DATE:
 868         case DT_DATE_TZ:
 869         case DT_DATETIME:
 870         case DT_DATETIME_TZ:
 871         case DT_FIXED_14_4:
 872         case DT_FLOAT:
 873         case DT_I1:
 874         case DT_I2:
 875         case DT_I4:
 876         case DT_I8:
 877         case DT_INT:
 878         case DT_NMTOKEN:
 879         case DT_NMTOKENS:
 880         case DT_NUMBER:
 881         case DT_R4:
 882         case DT_R8:
 883         case DT_STRING:
 884         case DT_TIME:
 885         case DT_TIME_TZ:
 886         case DT_UI1:
 887         case DT_UI2:
 888         case DT_UI4:
 889         case DT_UI8:
 890         case DT_URI:
 891         case DT_UUID:
 892             {
 893                 xmlAttrPtr attr = xmlHasNsProp(get_element(This), DT_prefix, DT_nsURI);
 894                 if (attr)
 895                 {
 896                     attr = xmlSetNsProp(get_element(This), attr->ns, DT_prefix, dt_to_str(dt));
 897                     hr = S_OK;
 898                 }
 899                 else
 900                 {
 901                     xmlNsPtr ns = xmlNewNs(get_element(This), DT_nsURI, DT_prefix);
 902                     if (ns)
 903                     {
 904                         attr = xmlNewNsProp(get_element(This), ns, DT_prefix, dt_to_str(dt));
 905                         if (attr)
 906                         {
 907                             xmlAddChild(get_element(This), (xmlNodePtr)attr);
 908                             hr = S_OK;
 909                         }
 910                         else
 911                             ERR("Failed to create Attribute\n");
 912                     }
 913                     else
 914                         ERR("Failed to create Namespace\n");
 915                 }
 916             }
 917             break;
 918         default:
 919             FIXME("need to handle dt:%s\n", dt_to_str(dt));
 920             break;
 921         }
 922     }
 923
 924     return hr;
 925 }
 926
 927 static HRESULT WINAPI domelem_get_xml(
 928     IXMLDOMElement *iface,
 929     BSTR* p)
 930 {
 931     domelem *This = impl_from_IXMLDOMElement( iface );
 932
 933     TRACE("(%p)->(%p)\n", This, p);
 934
 935     return node_get_xml(&This->node, TRUE, FALSE, p);
 936 }
 937
 938 static HRESULT WINAPI domelem_transformNode(
 939     IXMLDOMElement *iface,
 940     IXMLDOMNode *node, BSTR *p)
 941 {
 942     domelem *This = impl_from_IXMLDOMElement( iface );
 943     TRACE("(%p)->(%p %p)\n", This, node, p);
 944     return node_transform_node(&This->node, node, p);
 945 }
 946
 947 static HRESULT WINAPI domelem_selectNodes(
 948     IXMLDOMElement *iface,
 949     BSTR p, IXMLDOMNodeList** outList)
 950 {
 951     domelem *This = impl_from_IXMLDOMElement( iface );
 952     TRACE("(%p)->(%s %p)\n", This, debugstr_w(p), outList);
 953     return node_select_nodes(&This->node, p, outList);
 954 }
 955
 956 static HRESULT WINAPI domelem_selectSingleNode(
 957     IXMLDOMElement *iface,
 958     BSTR p, IXMLDOMNode** outNode)
 959 {
 960     domelem *This = impl_from_IXMLDOMElement( iface );
 961     TRACE("(%p)->(%s %p)\n", This, debugstr_w(p), outNode);
 962     return node_select_singlenode(&This->node, p, outNode);
 963 }
 964
 965 static HRESULT WINAPI domelem_get_parsed(
 966     IXMLDOMElement *iface,
 967     VARIANT_BOOL* isParsed)
 968 {
 969     domelem *This = impl_from_IXMLDOMElement( iface );
 970     FIXME("(%p)->(%p) stub!\n", This, isParsed);
 971     *isParsed = VARIANT_TRUE;
 972     return S_OK;
 973 }
 974
 975 static HRESULT WINAPI domelem_get_namespaceURI(
 976     IXMLDOMElement *iface,
 977     BSTR* p)
 978 {
 979     domelem *This = impl_from_IXMLDOMElement( iface );
 980     TRACE("(%p)->(%p)\n", This, p);
 981     return node_get_namespaceURI(&This->node, p);
 982 }
 983
 984 static HRESULT WINAPI domelem_get_prefix(
 985     IXMLDOMElement *iface,
 986     BSTR* prefix)
 987 {
 988     domelem *This = impl_from_IXMLDOMElement( iface );
 989     TRACE("(%p)->(%p)\n", This, prefix);
 990     return node_get_prefix( &This->node, prefix );
 991 }
 992
 993 static HRESULT WINAPI domelem_get_baseName(
 994     IXMLDOMElement *iface,
 995     BSTR* name)
 996 {
 997     domelem *This = impl_from_IXMLDOMElement( iface );
 998     TRACE("(%p)->(%p)\n", This, name);
 999     return node_get_base_name( &This->node, name );
1000 }
1001
1002 static HRESULT WINAPI domelem_transformNodeToObject(
1003     IXMLDOMElement *iface,
1004     IXMLDOMNode* domNode, VARIANT var1)
1005 {
1006     domelem *This = impl_from_IXMLDOMElement( iface );
1007     FIXME("(%p)->(%p %s)\n", This, domNode, debugstr_variant(&var1));
1008     return E_NOTIMPL;
1009 }
1010
1011 static HRESULT WINAPI domelem_get_tagName(
1012     IXMLDOMElement *iface,
1013     BSTR* p)
1014 {
1015     domelem *This = impl_from_IXMLDOMElement( iface );
1016     xmlNodePtr element;
1017     const xmlChar *prefix;
1018     xmlChar *qname;
1019
1020     TRACE("(%p)->(%p)\n", This, p );
1021
1022     if (!p) return E_INVALIDARG;
1023
1024     element = get_element( This );
1025     if ( !element )
1026         return E_FAIL;
1027
1028     prefix = element->ns ? element->ns->prefix : NULL;
1029     qname = xmlBuildQName(element->name, prefix, NULL, 0);
1030
1031     *p = bstr_from_xmlChar(qname);
1032     if (qname != element->name) xmlFree(qname);
1033
1034     return *p ? S_OK : E_OUTOFMEMORY;
1035 }
1036
1037 static HRESULT WINAPI domelem_getAttribute(
1038     IXMLDOMElement *iface,
1039     BSTR name, VARIANT* value)
1040 {
1041     domelem *This = impl_from_IXMLDOMElement( iface );
1042     xmlNodePtr element;
1043     xmlChar *xml_name, *xml_value = NULL;
1044     HRESULT hr = S_FALSE;
1045
1046     TRACE("(%p)->(%s %p)\n", This, debugstr_w(name), value);
1047
1048     if(!value || !name)
1049         return E_INVALIDARG;
1050
1051     element = get_element( This );
1052     if ( !element )
1053         return E_FAIL;
1054
1055     V_BSTR(value) = NULL;
1056     V_VT(value) = VT_NULL;
1057
1058     xml_name = xmlChar_from_wchar( name );
1059
1060     if(!xmlValidateNameValue(xml_name))
1061         hr = E_FAIL;
1062     else
1063         xml_value = xmlGetNsProp(element, xml_name, NULL);
1064
1065     heap_free(xml_name);
1066     if(xml_value)
1067     {
1068         V_VT(value) = VT_BSTR;
1069         V_BSTR(value) = bstr_from_xmlChar( xml_value );
1070         xmlFree(xml_value);
1071         hr = S_OK;
1072     }
1073
1074     return hr;
1075 }
1076
1077 static HRESULT WINAPI domelem_setAttribute(
1078     IXMLDOMElement *iface,
1079     BSTR name, VARIANT value)
1080 {
1081     domelem *This = impl_from_IXMLDOMElement( iface );
1082     xmlNodePtr element;
1083     xmlChar *xml_name, *xml_value;
1084     HRESULT hr;
1085     VARIANT var;
1086
1087     TRACE("(%p)->(%s %s)\n", This, debugstr_w(name), debugstr_variant(&value));
1088
1089     element = get_element( This );
1090     if ( !element )
1091         return E_FAIL;
1092
1093     VariantInit(&var);
1094     hr = VariantChangeType(&var, &value, 0, VT_BSTR);
1095     if(hr != S_OK)
1096     {
1097         FIXME("VariantChangeType failed\n");
1098         return hr;
1099     }
1100
1101     xml_name = xmlChar_from_wchar( name );
1102     xml_value = xmlChar_from_wchar( V_BSTR(&var) );
1103
1104     if(!xmlSetNsProp(element, NULL,  xml_name, xml_value))
1105         hr = E_FAIL;
1106
1107     heap_free(xml_value);
1108     heap_free(xml_name);
1109     VariantClear(&var);
1110
1111     return hr;
1112 }
1113
1114 static HRESULT WINAPI domelem_removeAttribute(
1115     IXMLDOMElement *iface,
1116     BSTR p)
1117 {
1118     domelem *This = impl_from_IXMLDOMElement( iface );
1119     IXMLDOMNamedNodeMap *attr;
1120     HRESULT hr;
1121
1122     TRACE("(%p)->(%s)\n", This, debugstr_w(p));
1123
1124     hr = IXMLDOMElement_get_attributes(iface, &attr);
1125     if (hr != S_OK) return hr;
1126
1127     hr = IXMLDOMNamedNodeMap_removeNamedItem(attr, p, NULL);
1128     IXMLDOMNamedNodeMap_Release(attr);
1129
1130     return hr;
1131 }
1132
1133 static HRESULT WINAPI domelem_getAttributeNode(
1134     IXMLDOMElement *iface,
1135     BSTR p, IXMLDOMAttribute** attributeNode )
1136 {
1137     domelem *This = impl_from_IXMLDOMElement( iface );
1138     xmlChar *xml_name;
1139     xmlNodePtr element;
1140     xmlAttrPtr attr;
1141     IUnknown *unk;
1142     HRESULT hr = S_FALSE;
1143
1144     TRACE("(%p)->(%s %p)\n", This, debugstr_w(p), attributeNode);
1145
1146     if(!attributeNode)
1147         return E_FAIL;
1148
1149     *attributeNode = NULL;
1150
1151     element = get_element( This );
1152     if ( !element )
1153         return E_FAIL;
1154
1155     xml_name = xmlChar_from_wchar(p);
1156
1157     if(!xmlValidateNameValue(xml_name))
1158     {
1159         heap_free(xml_name);
1160         return E_FAIL;
1161     }
1162
1163     attr = xmlHasProp(element, xml_name);
1164     if(attr) {
1165         unk = create_attribute((xmlNodePtr)attr);
1166         hr = IUnknown_QueryInterface(unk, &IID_IXMLDOMAttribute, (void**)attributeNode);
1167         IUnknown_Release(unk);
1168     }
1169
1170     heap_free(xml_name);
1171
1172     return hr;
1173 }
1174
1175 static HRESULT WINAPI domelem_setAttributeNode(
1176     IXMLDOMElement *iface,
1177     IXMLDOMAttribute* attribute,
1178     IXMLDOMAttribute** old)
1179 {
1180     domelem *This = impl_from_IXMLDOMElement( iface );
1181     xmlChar *name, *value;
1182     BSTR nameW, prefix;
1183     xmlAttrPtr attr;
1184     VARIANT valueW;
1185     HRESULT hr;
1186
1187     FIXME("(%p)->(%p %p): semi-stub\n", This, attribute, old);
1188
1189     if (!attribute) return E_INVALIDARG;
1190
1191     if (old) *old = NULL;
1192
1193     hr = IXMLDOMAttribute_get_nodeName(attribute, &nameW);
1194     if (hr != S_OK) return hr;
1195
1196     hr = IXMLDOMAttribute_get_nodeValue(attribute, &valueW);
1197     if (hr != S_OK)
1198     {
1199         SysFreeString(nameW);
1200         return hr;
1201     }
1202
1203     TRACE("attribute: %s=%s\n", debugstr_w(nameW), debugstr_w(V_BSTR(&valueW)));
1204
1205     hr = IXMLDOMAttribute_get_prefix(attribute, &prefix);
1206     if (hr == S_OK)
1207     {
1208         FIXME("namespaces not supported: %s\n", debugstr_w(prefix));
1209         SysFreeString(prefix);
1210     }
1211
1212     name = xmlChar_from_wchar(nameW);
1213     value = xmlChar_from_wchar(V_BSTR(&valueW));
1214
1215     if (!name || !value)
1216     {
1217         SysFreeString(nameW);
1218         VariantClear(&valueW);
1219         heap_free(name);
1220         heap_free(value);
1221         return E_OUTOFMEMORY;
1222     }
1223
1224     attr = xmlSetNsProp(get_element(This), NULL, name, value);
1225
1226     SysFreeString(nameW);
1227     VariantClear(&valueW);
1228     heap_free(name);
1229     heap_free(value);
1230
1231     return attr ? S_OK : E_FAIL;
1232 }
1233
1234 static HRESULT WINAPI domelem_removeAttributeNode(
1235     IXMLDOMElement *iface,
1236     IXMLDOMAttribute* domAttribute,
1237     IXMLDOMAttribute** attributeNode)
1238 {
1239     domelem *This = impl_from_IXMLDOMElement( iface );
1240     FIXME("(%p)->(%p %p)\n", This, domAttribute, attributeNode);
1241     return E_NOTIMPL;
1242 }
1243
1244 static HRESULT WINAPI domelem_getElementsByTagName(
1245     IXMLDOMElement *iface,
1246     BSTR tagName, IXMLDOMNodeList** resultList)
1247 {
1248     domelem *This = impl_from_IXMLDOMElement( iface );
1249     xmlChar *query;
1250     HRESULT hr;
1251     BOOL XPath;
1252
1253     TRACE("(%p)->(%s, %p)\n", This, debugstr_w(tagName), resultList);
1254
1255     if (!tagName || !resultList) return E_INVALIDARG;
1256
1257     XPath = is_xpathmode(get_element(This)->doc);
1258     set_xpathmode(get_element(This)->doc, TRUE);
1259     query = tagName_to_XPath(tagName);
1260     hr = queryresult_create(get_element(This), query, resultList);
1261     xmlFree(query);
1262     set_xpathmode(get_element(This)->doc, XPath);
1263
1264     return hr;
1265 }
1266
1267 static HRESULT WINAPI domelem_normalize(
1268     IXMLDOMElement *iface )
1269 {
1270     domelem *This = impl_from_IXMLDOMElement( iface );
1271     FIXME("%p\n", This);
1272     return E_NOTIMPL;
1273 }
1274
1275 static const struct IXMLDOMElementVtbl domelem_vtbl =
1276 {
1277     domelem_QueryInterface,
1278     domelem_AddRef,
1279     domelem_Release,
1280     domelem_GetTypeInfoCount,
1281     domelem_GetTypeInfo,
1282     domelem_GetIDsOfNames,
1283     domelem_Invoke,
1284     domelem_get_nodeName,
1285     domelem_get_nodeValue,
1286     domelem_put_nodeValue,
1287     domelem_get_nodeType,
1288     domelem_get_parentNode,
1289     domelem_get_childNodes,
1290     domelem_get_firstChild,
1291     domelem_get_lastChild,
1292     domelem_get_previousSibling,
1293     domelem_get_nextSibling,
1294     domelem_get_attributes,
1295     domelem_insertBefore,
1296     domelem_replaceChild,
1297     domelem_removeChild,
1298     domelem_appendChild,
1299     domelem_hasChildNodes,
1300     domelem_get_ownerDocument,
1301     domelem_cloneNode,
1302     domelem_get_nodeTypeString,
1303     domelem_get_text,
1304     domelem_put_text,
1305     domelem_get_specified,
1306     domelem_get_definition,
1307     domelem_get_nodeTypedValue,
1308     domelem_put_nodeTypedValue,
1309     domelem_get_dataType,
1310     domelem_put_dataType,
1311     domelem_get_xml,
1312     domelem_transformNode,
1313     domelem_selectNodes,
1314     domelem_selectSingleNode,
1315     domelem_get_parsed,
1316     domelem_get_namespaceURI,
1317     domelem_get_prefix,
1318     domelem_get_baseName,
1319     domelem_transformNodeToObject,
1320     domelem_get_tagName,
1321     domelem_getAttribute,
1322     domelem_setAttribute,
1323     domelem_removeAttribute,
1324     domelem_getAttributeNode,
1325     domelem_setAttributeNode,
1326     domelem_removeAttributeNode,
1327     domelem_getElementsByTagName,
1328     domelem_normalize,
1329 };
1330
1331 static const tid_t domelem_iface_tids[] = {
1332     IXMLDOMElement_tid,
1333     0
1334 };
1335
1336 static dispex_static_data_t domelem_dispex = {
1337     NULL,
1338     IXMLDOMElement_tid,
1339     NULL,
1340     domelem_iface_tids
1341 };
1342
1343 IUnknown* create_element( xmlNodePtr element )
1344 {
1345     domelem *This;
1346
1347     This = heap_alloc( sizeof *This );
1348     if ( !This )
1349         return NULL;
1350
1351     This->IXMLDOMElement_iface.lpVtbl = &domelem_vtbl;
1352     This->ref = 1;
1353
1354     init_xmlnode(&This->node, element, (IXMLDOMNode*)&This->IXMLDOMElement_iface, &domelem_dispex);
1355
1356     return (IUnknown*)&This->IXMLDOMElement_iface;
1357 }
1358
1359 #endif