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