reactos/dll/win32/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 WIN32_NO_STATUS
  22 #define _INC_WINDOWS
  23
  24 #define COBJMACROS
  25
  26 #include <config.h>
  27
  28 //#include <stdarg.h>
  29 #ifdef HAVE_LIBXML2
  30 # include <libxml/parser.h>
  31 //# include <libxml/xmlerror.h>
  32 #endif
  33
  34 #include <windef.h>
  35 #include <winbase.h>
  36 //#include "winuser.h"
  37 //#include "winnls.h"
  38 #include <ole2.h>
  39 #include <msxml6.h>
  40
  41 #include "msxml_private.h"
  42
  43 #include <wine/debug.h>
  44
  45 WINE_DEFAULT_DEBUG_CHANNEL(msxml);
  46
  47 #ifdef HAVE_LIBXML2
  48
  49 static const xmlChar DT_prefix[] = "dt";
  50 static const xmlChar DT_nsURI[] = "urn:schemas-microsoft-com:datatypes";
  51
  52 typedef struct _domelem
  53 {
  54     xmlnode node;
  55     IXMLDOMElement IXMLDOMElement_iface;
  56     LONG ref;
  57 } domelem;
  58
  59 static const struct nodemap_funcs domelem_attr_map;
  60
  61 static const tid_t domelem_se_tids[] = {
  62     IXMLDOMNode_tid,
  63     IXMLDOMElement_tid,
  64     0
  65 };
  66
  67 static inline domelem *impl_from_IXMLDOMElement( IXMLDOMElement *iface )
  68 {
  69     return CONTAINING_RECORD(iface, domelem, IXMLDOMElement_iface);
  70 }
  71
  72 static inline xmlNodePtr get_element( const domelem *This )
  73 {
  74     return This->node.node;
  75 }
  76
  77 static HRESULT WINAPI domelem_QueryInterface(
  78     IXMLDOMElement *iface,
  79     REFIID riid,
  80     void** ppvObject )
  81 {
  82     domelem *This = impl_from_IXMLDOMElement( iface );
  83
  84     TRACE("(%p)->(%s %p)\n", This, debugstr_guid(riid), ppvObject);
  85
  86     if ( IsEqualGUID( riid, &IID_IXMLDOMElement ) ||
  87          IsEqualGUID( riid, &IID_IXMLDOMNode ) ||
  88          IsEqualGUID( riid, &IID_IDispatch ) ||
  89          IsEqualGUID( riid, &IID_IUnknown ) )
  90     {
  91         *ppvObject = &This->IXMLDOMElement_iface;
  92     }
  93     else if(node_query_interface(&This->node, riid, ppvObject))
  94     {
  95         return *ppvObject ? S_OK : E_NOINTERFACE;
  96     }
  97     else if(IsEqualGUID( riid, &IID_ISupportErrorInfo ))
  98     {
  99         return node_create_supporterrorinfo(domelem_se_tids, ppvObject);
 100     }
 101     else
 102     {
 103         TRACE("interface %s not implemented\n", debugstr_guid(riid));
 104         *ppvObject = NULL;
 105         return E_NOINTERFACE;
 106     }
 107
 108     IUnknown_AddRef( (IUnknown*)*ppvObject );
 109     return S_OK;
 110 }
 111
 112 static ULONG WINAPI domelem_AddRef(
 113     IXMLDOMElement *iface )
 114 {
 115     domelem *This = impl_from_IXMLDOMElement( iface );
 116     LONG ref = InterlockedIncrement(&This->ref);
 117
 118     TRACE("(%p)->(%d)\n", This, ref);
 119
 120     return ref;
 121 }
 122
 123 static ULONG WINAPI domelem_Release(
 124     IXMLDOMElement *iface )
 125 {
 126     domelem *This = impl_from_IXMLDOMElement( iface );
 127     ULONG ref = InterlockedDecrement(&This->ref);
 128
 129     TRACE("(%p)->(%d)\n", This, ref);
 130
 131     if(!ref) {
 132         destroy_xmlnode(&This->node);
 133         heap_free(This);
 134     }
 135
 136     return ref;
 137 }
 138
 139 static HRESULT WINAPI domelem_GetTypeInfoCount(
 140     IXMLDOMElement *iface,
 141     UINT* pctinfo )
 142 {
 143     domelem *This = impl_from_IXMLDOMElement( iface );
 144     return IDispatchEx_GetTypeInfoCount(&This->node.dispex.IDispatchEx_iface, pctinfo);
 145 }
 146
 147 static HRESULT WINAPI domelem_GetTypeInfo(
 148     IXMLDOMElement *iface,
 149     UINT iTInfo, LCID lcid,
 150     ITypeInfo** ppTInfo )
 151 {
 152     domelem *This = impl_from_IXMLDOMElement( iface );
 153     return IDispatchEx_GetTypeInfo(&This->node.dispex.IDispatchEx_iface,
 154         iTInfo, lcid, ppTInfo);
 155 }
 156
 157 static HRESULT WINAPI domelem_GetIDsOfNames(
 158     IXMLDOMElement *iface,
 159     REFIID riid, LPOLESTR* rgszNames,
 160     UINT cNames, LCID lcid, DISPID* rgDispId )
 161 {
 162     domelem *This = impl_from_IXMLDOMElement( iface );
 163     return IDispatchEx_GetIDsOfNames(&This->node.dispex.IDispatchEx_iface,
 164         riid, rgszNames, cNames, lcid, rgDispId);
 165 }
 166
 167 static HRESULT WINAPI domelem_Invoke(
 168     IXMLDOMElement *iface,
 169     DISPID dispIdMember, REFIID riid, LCID lcid,
 170     WORD wFlags, DISPPARAMS* pDispParams, VARIANT* pVarResult,
 171     EXCEPINFO* pExcepInfo, UINT* puArgErr )
 172 {
 173     domelem *This = impl_from_IXMLDOMElement( iface );
 174     return IDispatchEx_Invoke(&This->node.dispex.IDispatchEx_iface,
 175         dispIdMember, riid, lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
 176 }
 177
 178 static HRESULT WINAPI domelem_get_nodeName(
 179     IXMLDOMElement *iface,
 180     BSTR* p )
 181 {
 182     domelem *This = impl_from_IXMLDOMElement( iface );
 183
 184     TRACE("(%p)->(%p)\n", This, p);
 185
 186     return node_get_nodeName(&This->node, p);
 187 }
 188
 189 static HRESULT WINAPI domelem_get_nodeValue(
 190     IXMLDOMElement *iface,
 191     VARIANT* value)
 192 {
 193     domelem *This = impl_from_IXMLDOMElement( iface );
 194
 195     TRACE("(%p)->(%p)\n", This, value);
 196
 197     if(!value)
 198         return E_INVALIDARG;
 199
 200     V_VT(value) = VT_NULL;
 201     V_BSTR(value) = NULL; /* tests show that we should do this */
 202     return S_FALSE;
 203 }
 204
 205 static HRESULT WINAPI domelem_put_nodeValue(
 206     IXMLDOMElement *iface,
 207     VARIANT value)
 208 {
 209     domelem *This = impl_from_IXMLDOMElement( iface );
 210     TRACE("(%p)->(%s)\n", This, debugstr_variant(&value));
 211     return E_FAIL;
 212 }
 213
 214 static HRESULT WINAPI domelem_get_nodeType(
 215     IXMLDOMElement *iface,
 216     DOMNodeType* domNodeType )
 217 {
 218     domelem *This = impl_from_IXMLDOMElement( iface );
 219
 220     TRACE("(%p)->(%p)\n", This, domNodeType);
 221
 222     *domNodeType = NODE_ELEMENT;
 223     return S_OK;
 224 }
 225
 226 static HRESULT WINAPI domelem_get_parentNode(
 227     IXMLDOMElement *iface,
 228     IXMLDOMNode** parent )
 229 {
 230     domelem *This = impl_from_IXMLDOMElement( iface );
 231
 232     TRACE("(%p)->(%p)\n", This, parent);
 233
 234     return node_get_parent(&This->node, parent);
 235 }
 236
 237 static HRESULT WINAPI domelem_get_childNodes(
 238     IXMLDOMElement *iface,
 239     IXMLDOMNodeList** outList)
 240 {
 241     domelem *This = impl_from_IXMLDOMElement( iface );
 242
 243     TRACE("(%p)->(%p)\n", This, outList);
 244
 245     return node_get_child_nodes(&This->node, outList);
 246 }
 247
 248 static HRESULT WINAPI domelem_get_firstChild(
 249     IXMLDOMElement *iface,
 250     IXMLDOMNode** domNode)
 251 {
 252     domelem *This = impl_from_IXMLDOMElement( iface );
 253
 254     TRACE("(%p)->(%p)\n", This, domNode);
 255
 256     return node_get_first_child(&This->node, domNode);
 257 }
 258
 259 static HRESULT WINAPI domelem_get_lastChild(
 260     IXMLDOMElement *iface,
 261     IXMLDOMNode** domNode)
 262 {
 263     domelem *This = impl_from_IXMLDOMElement( iface );
 264
 265     TRACE("(%p)->(%p)\n", This, domNode);
 266
 267     return node_get_last_child(&This->node, domNode);
 268 }
 269
 270 static HRESULT WINAPI domelem_get_previousSibling(
 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_previous_sibling(&This->node, domNode);
 279 }
 280
 281 static HRESULT WINAPI domelem_get_nextSibling(
 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_next_sibling(&This->node, domNode);
 290 }
 291
 292 static HRESULT WINAPI domelem_get_attributes(
 293     IXMLDOMElement *iface,
 294     IXMLDOMNamedNodeMap** map)
 295 {
 296     domelem *This = impl_from_IXMLDOMElement( iface );
 297
 298     TRACE("(%p)->(%p)\n", This, map);
 299
 300     *map = create_nodemap(This->node.node, &domelem_attr_map);
 301     return S_OK;
 302 }
 303
 304 static HRESULT WINAPI domelem_insertBefore(
 305     IXMLDOMElement *iface,
 306     IXMLDOMNode* newNode, VARIANT refChild,
 307     IXMLDOMNode** old_node)
 308 {
 309     domelem *This = impl_from_IXMLDOMElement( iface );
 310     DOMNodeType type;
 311     HRESULT hr;
 312
 313     TRACE("(%p)->(%p %s %p)\n", This, newNode, debugstr_variant(&refChild), old_node);
 314
 315     hr = IXMLDOMNode_get_nodeType(newNode, &type);
 316     if (hr != S_OK) return hr;
 317
 318     TRACE("new node type %d\n", type);
 319     switch (type)
 320     {
 321         case NODE_DOCUMENT:
 322         case NODE_DOCUMENT_TYPE:
 323         case NODE_ENTITY:
 324         case NODE_NOTATION:
 325             if (old_node) *old_node = NULL;
 326             return E_FAIL;
 327         default:
 328             return node_insert_before(&This->node, newNode, &refChild, old_node);
 329     }
 330 }
 331
 332 static HRESULT WINAPI domelem_replaceChild(
 333     IXMLDOMElement *iface,
 334     IXMLDOMNode* newNode,
 335     IXMLDOMNode* oldNode,
 336     IXMLDOMNode** outOldNode)
 337 {
 338     domelem *This = impl_from_IXMLDOMElement( iface );
 339
 340     TRACE("(%p)->(%p %p %p)\n", This, newNode, oldNode, outOldNode);
 341
 342     return node_replace_child(&This->node, newNode, oldNode, outOldNode);
 343 }
 344
 345 static HRESULT WINAPI domelem_removeChild(
 346     IXMLDOMElement *iface,
 347     IXMLDOMNode *child, IXMLDOMNode **oldChild)
 348 {
 349     domelem *This = impl_from_IXMLDOMElement( iface );
 350     TRACE("(%p)->(%p %p)\n", This, child, oldChild);
 351     return node_remove_child(&This->node, child, oldChild);
 352 }
 353
 354 static HRESULT WINAPI domelem_appendChild(
 355     IXMLDOMElement *iface,
 356     IXMLDOMNode *child, IXMLDOMNode **outChild)
 357 {
 358     domelem *This = impl_from_IXMLDOMElement( iface );
 359     TRACE("(%p)->(%p %p)\n", This, child, outChild);
 360     return node_append_child(&This->node, child, outChild);
 361 }
 362
 363 static HRESULT WINAPI domelem_hasChildNodes(
 364     IXMLDOMElement *iface,
 365     VARIANT_BOOL *ret)
 366 {
 367     domelem *This = impl_from_IXMLDOMElement( iface );
 368     TRACE("(%p)->(%p)\n", This, ret);
 369     return node_has_childnodes(&This->node, ret);
 370 }
 371
 372 static HRESULT WINAPI domelem_get_ownerDocument(
 373     IXMLDOMElement   *iface,
 374     IXMLDOMDocument **doc)
 375 {
 376     domelem *This = impl_from_IXMLDOMElement( iface );
 377     TRACE("(%p)->(%p)\n", This, doc);
 378     return node_get_owner_doc(&This->node, doc);
 379 }
 380
 381 static HRESULT WINAPI domelem_cloneNode(
 382     IXMLDOMElement *iface,
 383     VARIANT_BOOL deep, IXMLDOMNode** outNode)
 384 {
 385     domelem *This = impl_from_IXMLDOMElement( iface );
 386     TRACE("(%p)->(%d %p)\n", This, deep, outNode);
 387     return node_clone( &This->node, deep, outNode );
 388 }
 389
 390 static HRESULT WINAPI domelem_get_nodeTypeString(
 391     IXMLDOMElement *iface,
 392     BSTR* p)
 393 {
 394     domelem *This = impl_from_IXMLDOMElement( iface );
 395     static const WCHAR elementW[] = {'e','l','e','m','e','n','t',0};
 396
 397     TRACE("(%p)->(%p)\n", This, p);
 398
 399     return return_bstr(elementW, p);
 400 }
 401
 402 static HRESULT WINAPI domelem_get_text(
 403     IXMLDOMElement *iface,
 404     BSTR* p)
 405 {
 406     domelem *This = impl_from_IXMLDOMElement( iface );
 407     TRACE("(%p)->(%p)\n", This, p);
 408     return node_get_text(&This->node, p);
 409 }
 410
 411 static HRESULT WINAPI domelem_put_text(
 412     IXMLDOMElement *iface,
 413     BSTR p)
 414 {
 415     domelem *This = impl_from_IXMLDOMElement( iface );
 416     TRACE("(%p)->(%s)\n", This, debugstr_w(p));
 417     return node_put_text( &This->node, p );
 418 }
 419
 420 static HRESULT WINAPI domelem_get_specified(
 421     IXMLDOMElement *iface,
 422     VARIANT_BOOL* isSpecified)
 423 {
 424     domelem *This = impl_from_IXMLDOMElement( iface );
 425     FIXME("(%p)->(%p) stub!\n", This, isSpecified);
 426     *isSpecified = VARIANT_TRUE;
 427     return S_OK;
 428 }
 429
 430 static HRESULT WINAPI domelem_get_definition(
 431     IXMLDOMElement *iface,
 432     IXMLDOMNode** definitionNode)
 433 {
 434     domelem *This = impl_from_IXMLDOMElement( iface );
 435     FIXME("(%p)->(%p)\n", This, definitionNode);
 436     return E_NOTIMPL;
 437 }
 438
 439 static inline BYTE hex_to_byte(xmlChar c)
 440 {
 441     if(c <= '9') return c-'0';
 442     if(c <= 'F') return c-'A'+10;
 443     return c-'a'+10;
 444 }
 445
 446 static inline BYTE base64_to_byte(xmlChar c)
 447 {
 448     if(c == '+') return 62;
 449     if(c == '/') return 63;
 450     if(c <= '9') return c-'0'+52;
 451     if(c <= 'Z') return c-'A';
 452     return c-'a'+26;
 453 }
 454
 455 static inline HRESULT variant_from_dt(XDR_DT dt, xmlChar* str, VARIANT* v)
 456 {
 457     VARIANT src;
 458     HRESULT hr = S_OK;
 459     BOOL handled = FALSE;
 460
 461     VariantInit(&src);
 462
 463     switch (dt)
 464     {
 465     case DT_INVALID:
 466     case DT_STRING:
 467     case DT_NMTOKEN:
 468     case DT_NMTOKENS:
 469     case DT_NUMBER:
 470     case DT_URI:
 471     case DT_UUID:
 472         {
 473             V_VT(v) = VT_BSTR;
 474             V_BSTR(v) = bstr_from_xmlChar(str);
 475
 476             if(!V_BSTR(v))
 477                 return E_OUTOFMEMORY;
 478             handled = TRUE;
 479         }
 480         break;
 481     case DT_DATE:
 482     case DT_DATE_TZ:
 483     case DT_DATETIME:
 484     case DT_DATETIME_TZ:
 485     case DT_TIME:
 486     case DT_TIME_TZ:
 487         {
 488             WCHAR *p, *e;
 489             SYSTEMTIME st;
 490             DOUBLE date = 0.0;
 491
 492             st.wYear = 1899;
 493             st.wMonth = 12;
 494             st.wDay = 30;
 495             st.wDayOfWeek = st.wHour = st.wMinute = st.wSecond = st.wMilliseconds = 0;
 496
 497             V_VT(&src) = VT_BSTR;
 498             V_BSTR(&src) = bstr_from_xmlChar(str);
 499
 500             if(!V_BSTR(&src))
 501                 return E_OUTOFMEMORY;
 502
 503             p = V_BSTR(&src);
 504             e = p + SysStringLen(V_BSTR(&src));
 505
 506             if(p+4<e && *(p+4)=='-') /* parse date (yyyy-mm-dd) */
 507             {
 508                 st.wYear = atoiW(p);
 509                 st.wMonth = atoiW(p+5);
 510                 st.wDay = atoiW(p+8);
 511                 p += 10;
 512
 513                 if(*p == 'T') p++;
 514             }
 515
 516             if(p+2<e && *(p+2)==':') /* parse time (hh:mm:ss.?) */
 517             {
 518                 st.wHour = atoiW(p);
 519                 st.wMinute = atoiW(p+3);
 520                 st.wSecond = atoiW(p+6);
 521                 p += 8;
 522
 523                 if(*p == '.')
 524                 {
 525                     p++;
 526                     while(isdigitW(*p)) p++;
 527                 }
 528             }
 529
 530             SystemTimeToVariantTime(&st, &date);
 531             V_VT(v) = VT_DATE;
 532             V_DATE(v) = date;
 533
 534             if(*p == '+') /* parse timezone offset (+hh:mm) */
 535                 V_DATE(v) += (DOUBLE)atoiW(p+1)/24 + (DOUBLE)atoiW(p+4)/1440;
 536             else if(*p == '-') /* parse timezone offset (-hh:mm) */
 537                 V_DATE(v) -= (DOUBLE)atoiW(p+1)/24 + (DOUBLE)atoiW(p+4)/1440;
 538
 539             VariantClear(&src);
 540             handled = TRUE;
 541         }
 542         break;
 543     case DT_BIN_HEX:
 544         {
 545             SAFEARRAYBOUND sab;
 546             int i, len;
 547
 548             len = xmlStrlen(str)/2;
 549             sab.lLbound = 0;
 550             sab.cElements = len;
 551
 552             V_VT(v) = (VT_ARRAY|VT_UI1);
 553             V_ARRAY(v) = SafeArrayCreate(VT_UI1, 1, &sab);
 554
 555             if(!V_ARRAY(v))
 556                 return E_OUTOFMEMORY;
 557
 558             for(i=0; i<len; i++)
 559                 ((BYTE*)V_ARRAY(v)->pvData)[i] = (hex_to_byte(str[2*i])<<4)
 560                     + hex_to_byte(str[2*i+1]);
 561             handled = TRUE;
 562         }
 563         break;
 564     case DT_BIN_BASE64:
 565         {
 566             SAFEARRAYBOUND sab;
 567             xmlChar *c1, *c2;
 568             int i, len;
 569
 570             /* remove all formatting chars */
 571             c1 = c2 = str;
 572             len = 0;
 573             while (*c2)
 574             {
 575                 if ( *c2 == ' '  || *c2 == '\t' ||
 576                      *c2 == '\n' || *c2 == '\r' )
 577                 {
 578                     c2++;
 579                     continue;
 580                 }
 581                 *c1++ = *c2++;
 582                 len++;
 583             }
 584
 585             /* skip padding */
 586             if(str[len-2] == '=') i = 2;
 587             else if(str[len-1] == '=') i = 1;
 588             else i = 0;
 589
 590             sab.lLbound = 0;
 591             sab.cElements = len/4*3-i;
 592
 593             V_VT(v) = (VT_ARRAY|VT_UI1);
 594             V_ARRAY(v) = SafeArrayCreate(VT_UI1, 1, &sab);
 595
 596             if(!V_ARRAY(v))
 597                 return E_OUTOFMEMORY;
 598
 599             for(i=0; i<len/4; i++)
 600             {
 601                 ((BYTE*)V_ARRAY(v)->pvData)[3*i] = (base64_to_byte(str[4*i])<<2)
 602                     + (base64_to_byte(str[4*i+1])>>4);
 603                 if(3*i+1 < sab.cElements)
 604                     ((BYTE*)V_ARRAY(v)->pvData)[3*i+1] = (base64_to_byte(str[4*i+1])<<4)
 605                         + (base64_to_byte(str[4*i+2])>>2);
 606                 if(3*i+2 < sab.cElements)
 607                     ((BYTE*)V_ARRAY(v)->pvData)[3*i+2] = (base64_to_byte(str[4*i+2])<<6)
 608                         + base64_to_byte(str[4*i+3]);
 609             }
 610             handled = TRUE;
 611         }
 612         break;
 613     case DT_BOOLEAN:
 614         V_VT(v) = VT_BOOL;
 615         break;
 616     case DT_FIXED_14_4:
 617         V_VT(v) = VT_CY;
 618         break;
 619     case DT_I1:
 620         V_VT(v) = VT_I1;
 621         break;
 622     case DT_I2:
 623         V_VT(v) = VT_I2;
 624         break;
 625     case DT_I4:
 626     case DT_INT:
 627         V_VT(v) = VT_I4;
 628         break;
 629     case DT_I8:
 630         V_VT(v) = VT_I8;
 631         break;
 632     case DT_R4:
 633         V_VT(v) = VT_R4;
 634         break;
 635     case DT_FLOAT:
 636     case DT_R8:
 637         V_VT(v) = VT_R8;
 638         break;
 639     case DT_UI1:
 640         V_VT(v) = VT_UI1;
 641         break;
 642     case DT_UI2:
 643         V_VT(v) = VT_UI2;
 644         break;
 645     case DT_UI4:
 646         V_VT(v) = VT_UI4;
 647         break;
 648     case DT_UI8:
 649         V_VT(v) = VT_UI8;
 650         break;
 651     case DT_CHAR:
 652     case DT_ENTITY:
 653     case DT_ENTITIES:
 654     case DT_ENUMERATION:
 655     case DT_ID:
 656     case DT_IDREF:
 657     case DT_IDREFS:
 658     case DT_NOTATION:
 659         FIXME("need to handle dt:%s\n", debugstr_dt(dt));
 660         V_VT(v) = VT_BSTR;
 661         V_BSTR(v) = bstr_from_xmlChar(str);
 662         if (!V_BSTR(v))
 663             return E_OUTOFMEMORY;
 664         handled = TRUE;
 665         break;
 666     default:
 667         WARN("unknown type %d\n", dt);
 668     }
 669
 670     if (!handled)
 671     {
 672         V_VT(&src) = VT_BSTR;
 673         V_BSTR(&src) = bstr_from_xmlChar(str);
 674
 675         if(!V_BSTR(&src))
 676             return E_OUTOFMEMORY;
 677
 678         hr = VariantChangeTypeEx(v, &src,
 679                 MAKELCID(MAKELANGID(LANG_ENGLISH,SUBLANG_ENGLISH_US),SORT_DEFAULT),0, V_VT(v));
 680         VariantClear(&src);
 681     }
 682     return hr;
 683 }
 684
 685 static XDR_DT element_get_dt(xmlNodePtr node)
 686 {
 687     XDR_DT dt = DT_INVALID;
 688
 689     TRACE("(%p)\n", node);
 690     if(node->type != XML_ELEMENT_NODE)
 691     {
 692         FIXME("invalid element node\n");
 693         return dt;
 694     }
 695
 696     if (node->ns && xmlStrEqual(node->ns->href, DT_nsURI))
 697     {
 698         dt = str_to_dt(node->name, -1);
 699     }
 700     else
 701     {
 702         xmlChar* pVal = xmlGetNsProp(node, BAD_CAST "dt", DT_nsURI);
 703         if (pVal)
 704         {
 705             dt = str_to_dt(pVal, -1);
 706             xmlFree(pVal);
 707         }
 708         else if (node->doc)
 709         {
 710             IXMLDOMDocument3* doc = (IXMLDOMDocument3*)create_domdoc((xmlNodePtr)node->doc);
 711             if (doc)
 712             {
 713                 VARIANT v;
 714                 VariantInit(&v);
 715
 716                 if (IXMLDOMDocument3_get_schemas(doc, &v) == S_OK &&
 717                     V_VT(&v) == VT_DISPATCH)
 718                 {
 719                     dt = SchemaCache_get_node_dt((IXMLDOMSchemaCollection2*)V_DISPATCH(&v), node);
 720                 }
 721                 VariantClear(&v);
 722                 IXMLDOMDocument3_Release(doc);
 723             }
 724         }
 725     }
 726
 727     TRACE("=> dt:%s\n", debugstr_dt(dt));
 728     return dt;
 729 }
 730
 731 static HRESULT WINAPI domelem_get_nodeTypedValue(
 732     IXMLDOMElement *iface,
 733     VARIANT* v)
 734 {
 735     domelem *This = impl_from_IXMLDOMElement( iface );
 736     XDR_DT dt;
 737     xmlChar* content;
 738     HRESULT hr;
 739
 740     TRACE("(%p)->(%p)\n", This, v);
 741
 742     if(!v) return E_INVALIDARG;
 743
 744     V_VT(v) = VT_NULL;
 745
 746     dt = element_get_dt(get_element(This));
 747     content = xmlNodeGetContent(get_element(This));
 748     hr = variant_from_dt(dt, content, v);
 749     xmlFree(content);
 750
 751     return hr;
 752 }
 753
 754 static HRESULT encode_base64(const BYTE *buf, int len, BSTR *ret)
 755 {
 756     static const char b64[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
 757     const BYTE *d = buf;
 758     int bytes, pad_bytes, div;
 759     DWORD needed;
 760     WCHAR *ptr;
 761
 762     bytes = (len*8 + 5)/6;
 763     pad_bytes = (bytes % 4) ? 4 - (bytes % 4) : 0;
 764
 765     TRACE("%d, bytes is %d, pad bytes is %d\n", len, bytes, pad_bytes);
 766     needed = bytes + pad_bytes + 1;
 767
 768     *ret = SysAllocStringLen(NULL, needed);
 769     if (!*ret) return E_OUTOFMEMORY;
 770
 771     /* Three bytes of input give 4 chars of output */
 772     div = len / 3;
 773
 774     ptr = *ret;
 775     while (div > 0)
 776     {
 777         /* first char is the first 6 bits of the first byte*/
 778         *ptr++ = b64[ ( d[0] >> 2) & 0x3f ];
 779         /* second char is the last 2 bits of the first byte and the first 4
 780          * bits of the second byte */
 781         *ptr++ = b64[ ((d[0] << 4) & 0x30) | (d[1] >> 4 & 0x0f)];
 782         /* third char is the last 4 bits of the second byte and the first 2
 783          * bits of the third byte */
 784         *ptr++ = b64[ ((d[1] << 2) & 0x3c) | (d[2] >> 6 & 0x03)];
 785         /* fourth char is the remaining 6 bits of the third byte */
 786         *ptr++ = b64[   d[2]       & 0x3f];
 787         d += 3;
 788         div--;
 789     }
 790
 791     switch (pad_bytes)
 792     {
 793         case 1:
 794             /* first char is the first 6 bits of the first byte*/
 795             *ptr++ = b64[ ( d[0] >> 2) & 0x3f ];
 796             /* second char is the last 2 bits of the first byte and the first 4
 797              * bits of the second byte */
 798             *ptr++ = b64[ ((d[0] << 4) & 0x30) | (d[1] >> 4 & 0x0f)];
 799             /* third char is the last 4 bits of the second byte padded with
 800              * two zeroes */
 801             *ptr++ = b64[ ((d[1] << 2) & 0x3c) ];
 802             /* fourth char is a = to indicate one byte of padding */
 803             *ptr++ = '=';
 804             break;
 805         case 2:
 806             /* first char is the first 6 bits of the first byte*/
 807             *ptr++ = b64[ ( d[0] >> 2) & 0x3f ];
 808             /* second char is the last 2 bits of the first byte padded with
 809              * four zeroes*/
 810             *ptr++ = b64[ ((d[0] << 4) & 0x30)];
 811             /* third char is = to indicate padding */
 812             *ptr++ = '=';
 813             /* fourth char is = to indicate padding */
 814             *ptr++ = '=';
 815             break;
 816     }
 817
 818     return S_OK;
 819 }
 820
 821 static HRESULT encode_binhex(const BYTE *buf, int len, BSTR *ret)
 822 {
 823     static const char byte_to_hex[16] = "0123456789abcdef";
 824     int i;
 825
 826     *ret = SysAllocStringLen(NULL, len*2);
 827     if (!*ret) return E_OUTOFMEMORY;
 828
 829     for (i = 0; i < len; i++)
 830     {
 831         (*ret)[2*i]   = byte_to_hex[buf[i] >> 4];
 832         (*ret)[2*i+1] = byte_to_hex[0x0f & buf[i]];
 833     }
 834
 835     return S_OK;
 836 }
 837
 838 static HRESULT WINAPI domelem_put_nodeTypedValue(
 839     IXMLDOMElement *iface,
 840     VARIANT value)
 841 {
 842     domelem *This = impl_from_IXMLDOMElement( iface );
 843     XDR_DT dt;
 844     HRESULT hr;
 845
 846     TRACE("(%p)->(%s)\n", This, debugstr_variant(&value));
 847
 848     dt = element_get_dt(get_element(This));
 849     switch (dt)
 850     {
 851     /* for untyped node coerce to BSTR and set */
 852     case DT_INVALID:
 853         if (V_VT(&value) != VT_BSTR)
 854         {
 855             VARIANT content;
 856             VariantInit(&content);
 857             hr = VariantChangeType(&content, &value, 0, VT_BSTR);
 858             if (hr == S_OK)
 859             {
 860                 hr = node_set_content(&This->node, V_BSTR(&content));
 861                 VariantClear(&content);
 862             }
 863         }
 864         else
 865             hr = node_set_content(&This->node, V_BSTR(&value));
 866         break;
 867     case DT_BIN_BASE64:
 868         if (V_VT(&value) == VT_BSTR)
 869             hr = node_set_content(&This->node, V_BSTR(&value));
 870         else if (V_VT(&value) == (VT_UI1|VT_ARRAY))
 871         {
 872             UINT dim = SafeArrayGetDim(V_ARRAY(&value));
 873             LONG lbound, ubound;
 874             BSTR encoded;
 875             BYTE *ptr;
 876             int len;
 877
 878             if (dim > 1)
 879                 FIXME("unexpected array dimension count %u\n", dim);
 880
 881             SafeArrayGetUBound(V_ARRAY(&value), 1, &ubound);
 882             SafeArrayGetLBound(V_ARRAY(&value), 1, &lbound);
 883
 884             len = (ubound - lbound + 1)*SafeArrayGetElemsize(V_ARRAY(&value));
 885
 886             hr = SafeArrayAccessData(V_ARRAY(&value), (void*)&ptr);
 887             if (FAILED(hr)) return hr;
 888
 889             hr = encode_base64(ptr, len, &encoded);
 890             SafeArrayUnaccessData(V_ARRAY(&value));
 891             if (FAILED(hr)) return hr;
 892
 893             hr = node_set_content(&This->node, encoded);
 894             SysFreeString(encoded);
 895         }
 896         else
 897         {
 898             FIXME("unhandled variant type %d for dt:%s\n", V_VT(&value), debugstr_dt(dt));
 899             return E_NOTIMPL;
 900         }
 901         break;
 902     case DT_BIN_HEX:
 903         if (V_VT(&value) == (VT_UI1|VT_ARRAY))
 904         {
 905             UINT dim = SafeArrayGetDim(V_ARRAY(&value));
 906             LONG lbound, ubound;
 907             BSTR encoded;
 908             BYTE *ptr;
 909             int len;
 910
 911             if (dim > 1)
 912                 FIXME("unexpected array dimension count %u\n", dim);
 913
 914             SafeArrayGetUBound(V_ARRAY(&value), 1, &ubound);
 915             SafeArrayGetLBound(V_ARRAY(&value), 1, &lbound);
 916
 917             len = (ubound - lbound + 1)*SafeArrayGetElemsize(V_ARRAY(&value));
 918
 919             hr = SafeArrayAccessData(V_ARRAY(&value), (void*)&ptr);
 920             if (FAILED(hr)) return hr;
 921
 922             hr = encode_binhex(ptr, len, &encoded);
 923             SafeArrayUnaccessData(V_ARRAY(&value));
 924             if (FAILED(hr)) return hr;
 925
 926             hr = node_set_content(&This->node, encoded);
 927             SysFreeString(encoded);
 928         }
 929         else
 930         {
 931             FIXME("unhandled variant type %d for dt:%s\n", V_VT(&value), debugstr_dt(dt));
 932             return E_NOTIMPL;
 933         }
 934         break;
 935     default:
 936         FIXME("not implemented for dt:%s\n", debugstr_dt(dt));
 937         return E_NOTIMPL;
 938     }
 939
 940     return hr;
 941 }
 942
 943 static HRESULT WINAPI domelem_get_dataType(
 944     IXMLDOMElement *iface,
 945     VARIANT* typename)
 946 {
 947     domelem *This = impl_from_IXMLDOMElement( iface );
 948     XDR_DT dt;
 949
 950     TRACE("(%p)->(%p)\n", This, typename);
 951
 952     if (!typename)
 953         return E_INVALIDARG;
 954
 955     dt = element_get_dt(get_element(This));
 956     switch (dt)
 957     {
 958         case DT_BIN_BASE64:
 959         case DT_BIN_HEX:
 960         case DT_BOOLEAN:
 961         case DT_CHAR:
 962         case DT_DATE:
 963         case DT_DATE_TZ:
 964         case DT_DATETIME:
 965         case DT_DATETIME_TZ:
 966         case DT_FIXED_14_4:
 967         case DT_FLOAT:
 968         case DT_I1:
 969         case DT_I2:
 970         case DT_I4:
 971         case DT_I8:
 972         case DT_INT:
 973         case DT_NUMBER:
 974         case DT_R4:
 975         case DT_R8:
 976         case DT_TIME:
 977         case DT_TIME_TZ:
 978         case DT_UI1:
 979         case DT_UI2:
 980         case DT_UI4:
 981         case DT_UI8:
 982         case DT_URI:
 983         case DT_UUID:
 984             V_VT(typename) = VT_BSTR;
 985             V_BSTR(typename) = SysAllocString(dt_to_bstr(dt));
 986
 987             if (!V_BSTR(typename))
 988                 return E_OUTOFMEMORY;
 989             break;
 990         default:
 991             /* Other types (DTD equivalents) do not return anything here,
 992              * but the pointer part of the VARIANT is set to NULL */
 993             V_VT(typename) = VT_NULL;
 994             V_BSTR(typename) = NULL;
 995             break;
 996     }
 997     return (V_VT(typename) != VT_NULL) ? S_OK : S_FALSE;
 998 }
 999
1000 static HRESULT WINAPI domelem_put_dataType(
1001     IXMLDOMElement *iface,
1002     BSTR dtName)
1003 {
1004     domelem *This = impl_from_IXMLDOMElement( iface );
1005     HRESULT hr = E_FAIL;
1006     xmlChar *str;
1007     XDR_DT dt;
1008
1009     TRACE("(%p)->(%s)\n", This, debugstr_w(dtName));
1010
1011     if(dtName == NULL)
1012         return E_INVALIDARG;
1013
1014     dt = bstr_to_dt(dtName, -1);
1015
1016     /* An example of this is. The Text in the node needs to be a 0 or 1 for a boolean type.
1017        This applies to changing types (string->bool) or setting a new one
1018      */
1019     str = xmlNodeGetContent(get_element(This));
1020     hr = dt_validate(dt, str);
1021     xmlFree(str);
1022
1023     /* Check all supported types. */
1024     if (hr == S_OK)
1025     {
1026         switch (dt)
1027         {
1028         case DT_BIN_BASE64:
1029         case DT_BIN_HEX:
1030         case DT_BOOLEAN:
1031         case DT_CHAR:
1032         case DT_DATE:
1033         case DT_DATE_TZ:
1034         case DT_DATETIME:
1035         case DT_DATETIME_TZ:
1036         case DT_FIXED_14_4:
1037         case DT_FLOAT:
1038         case DT_I1:
1039         case DT_I2:
1040         case DT_I4:
1041         case DT_I8:
1042         case DT_INT:
1043         case DT_NMTOKEN:
1044         case DT_NMTOKENS:
1045         case DT_NUMBER:
1046         case DT_R4:
1047         case DT_R8:
1048         case DT_STRING:
1049         case DT_TIME:
1050         case DT_TIME_TZ:
1051         case DT_UI1:
1052         case DT_UI2:
1053         case DT_UI4:
1054         case DT_UI8:
1055         case DT_URI:
1056         case DT_UUID:
1057             {
1058                 xmlAttrPtr attr = xmlHasNsProp(get_element(This), DT_prefix, DT_nsURI);
1059                 if (attr)
1060                 {
1061                     attr = xmlSetNsProp(get_element(This), attr->ns, DT_prefix, dt_to_str(dt));
1062                     hr = S_OK;
1063                 }
1064                 else
1065                 {
1066                     xmlNsPtr ns = xmlNewNs(get_element(This), DT_nsURI, DT_prefix);
1067                     if (ns)
1068                     {
1069                         attr = xmlNewNsProp(get_element(This), ns, DT_prefix, dt_to_str(dt));
1070                         if (attr)
1071                         {
1072                             xmlAddChild(get_element(This), (xmlNodePtr)attr);
1073                             hr = S_OK;
1074                         }
1075                         else
1076                             ERR("Failed to create Attribute\n");
1077                     }
1078                     else
1079                         ERR("Failed to create Namespace\n");
1080                 }
1081             }
1082             break;
1083         default:
1084             FIXME("need to handle dt:%s\n", debugstr_dt(dt));
1085             break;
1086         }
1087     }
1088
1089     return hr;
1090 }
1091
1092 static HRESULT WINAPI domelem_get_xml(
1093     IXMLDOMElement *iface,
1094     BSTR* p)
1095 {
1096     domelem *This = impl_from_IXMLDOMElement( iface );
1097
1098     TRACE("(%p)->(%p)\n", This, p);
1099
1100     return node_get_xml(&This->node, TRUE, p);
1101 }
1102
1103 static HRESULT WINAPI domelem_transformNode(
1104     IXMLDOMElement *iface,
1105     IXMLDOMNode *node, BSTR *p)
1106 {
1107     domelem *This = impl_from_IXMLDOMElement( iface );
1108     TRACE("(%p)->(%p %p)\n", This, node, p);
1109     return node_transform_node(&This->node, node, p);
1110 }
1111
1112 static HRESULT WINAPI domelem_selectNodes(
1113     IXMLDOMElement *iface,
1114     BSTR p, IXMLDOMNodeList** outList)
1115 {
1116     domelem *This = impl_from_IXMLDOMElement( iface );
1117     TRACE("(%p)->(%s %p)\n", This, debugstr_w(p), outList);
1118     return node_select_nodes(&This->node, p, outList);
1119 }
1120
1121 static HRESULT WINAPI domelem_selectSingleNode(
1122     IXMLDOMElement *iface,
1123     BSTR p, IXMLDOMNode** outNode)
1124 {
1125     domelem *This = impl_from_IXMLDOMElement( iface );
1126     TRACE("(%p)->(%s %p)\n", This, debugstr_w(p), outNode);
1127     return node_select_singlenode(&This->node, p, outNode);
1128 }
1129
1130 static HRESULT WINAPI domelem_get_parsed(
1131     IXMLDOMElement *iface,
1132     VARIANT_BOOL* isParsed)
1133 {
1134     domelem *This = impl_from_IXMLDOMElement( iface );
1135     FIXME("(%p)->(%p) stub!\n", This, isParsed);
1136     *isParsed = VARIANT_TRUE;
1137     return S_OK;
1138 }
1139
1140 static HRESULT WINAPI domelem_get_namespaceURI(
1141     IXMLDOMElement *iface,
1142     BSTR* p)
1143 {
1144     domelem *This = impl_from_IXMLDOMElement( iface );
1145     TRACE("(%p)->(%p)\n", This, p);
1146     return node_get_namespaceURI(&This->node, p);
1147 }
1148
1149 static HRESULT WINAPI domelem_get_prefix(
1150     IXMLDOMElement *iface,
1151     BSTR* prefix)
1152 {
1153     domelem *This = impl_from_IXMLDOMElement( iface );
1154     TRACE("(%p)->(%p)\n", This, prefix);
1155     return node_get_prefix( &This->node, prefix );
1156 }
1157
1158 static HRESULT WINAPI domelem_get_baseName(
1159     IXMLDOMElement *iface,
1160     BSTR* name)
1161 {
1162     domelem *This = impl_from_IXMLDOMElement( iface );
1163     TRACE("(%p)->(%p)\n", This, name);
1164     return node_get_base_name( &This->node, name );
1165 }
1166
1167 static HRESULT WINAPI domelem_transformNodeToObject(
1168     IXMLDOMElement *iface,
1169     IXMLDOMNode* domNode, VARIANT var1)
1170 {
1171     domelem *This = impl_from_IXMLDOMElement( iface );
1172     FIXME("(%p)->(%p %s)\n", This, domNode, debugstr_variant(&var1));
1173     return E_NOTIMPL;
1174 }
1175
1176 static HRESULT WINAPI domelem_get_tagName(
1177     IXMLDOMElement *iface,
1178     BSTR* p)
1179 {
1180     domelem *This = impl_from_IXMLDOMElement( iface );
1181     xmlNodePtr element;
1182     const xmlChar *prefix;
1183     xmlChar *qname;
1184
1185     TRACE("(%p)->(%p)\n", This, p );
1186
1187     if (!p) return E_INVALIDARG;
1188
1189     element = get_element( This );
1190     if ( !element )
1191         return E_FAIL;
1192
1193     prefix = element->ns ? element->ns->prefix : NULL;
1194     qname = xmlBuildQName(element->name, prefix, NULL, 0);
1195
1196     *p = bstr_from_xmlChar(qname);
1197     if (qname != element->name) xmlFree(qname);
1198
1199     return *p ? S_OK : E_OUTOFMEMORY;
1200 }
1201
1202 static HRESULT WINAPI domelem_getAttribute(
1203     IXMLDOMElement *iface,
1204     BSTR name, VARIANT* value)
1205 {
1206     domelem *This = impl_from_IXMLDOMElement( iface );
1207     xmlNodePtr element;
1208     xmlChar *xml_name, *xml_value = NULL;
1209     HRESULT hr = S_FALSE;
1210
1211     TRACE("(%p)->(%s %p)\n", This, debugstr_w(name), value);
1212
1213     if(!value || !name)
1214         return E_INVALIDARG;
1215
1216     element = get_element( This );
1217     if ( !element )
1218         return E_FAIL;
1219
1220     V_BSTR(value) = NULL;
1221     V_VT(value) = VT_NULL;
1222
1223     xml_name = xmlchar_from_wchar( name );
1224
1225     if(!xmlValidateNameValue(xml_name))
1226         hr = E_FAIL;
1227     else
1228         xml_value = xmlGetNsProp(element, xml_name, NULL);
1229
1230     heap_free(xml_name);
1231     if(xml_value)
1232     {
1233         V_VT(value) = VT_BSTR;
1234         V_BSTR(value) = bstr_from_xmlChar( xml_value );
1235         xmlFree(xml_value);
1236         hr = S_OK;
1237     }
1238
1239     return hr;
1240 }
1241
1242 static HRESULT WINAPI domelem_setAttribute(
1243     IXMLDOMElement *iface,
1244     BSTR name, VARIANT value)
1245 {
1246     domelem *This = impl_from_IXMLDOMElement( iface );
1247     xmlChar *xml_name, *xml_value, *local, *prefix;
1248     xmlNodePtr element;
1249     HRESULT hr = S_OK;
1250
1251     TRACE("(%p)->(%s %s)\n", This, debugstr_w(name), debugstr_variant(&value));
1252
1253     element = get_element( This );
1254     if ( !element )
1255         return E_FAIL;
1256
1257     if (V_VT(&value) != VT_BSTR)
1258     {
1259         VARIANT var;
1260
1261         VariantInit(&var);
1262         hr = VariantChangeType(&var, &value, 0, VT_BSTR);
1263         if (hr != S_OK)
1264         {
1265             FIXME("VariantChangeType failed\n");
1266             return hr;
1267         }
1268
1269         xml_value = xmlchar_from_wchar(V_BSTR(&var));
1270         VariantClear(&var);
1271     }
1272     else
1273         xml_value = xmlchar_from_wchar(V_BSTR(&value));
1274
1275     xml_name = xmlchar_from_wchar( name );
1276
1277     if ((local = xmlSplitQName2(xml_name, &prefix)))
1278     {
1279         static const xmlChar* xmlnsA = (const xmlChar*)"xmlns";
1280         xmlNsPtr ns = NULL;
1281
1282         /* it's not allowed to modify existing namespace definition */
1283         if (xmlStrEqual(prefix, xmlnsA))
1284             ns = xmlSearchNs(element->doc, element, local);
1285
1286         xmlFree(prefix);
1287         xmlFree(local);
1288
1289         if (ns)
1290             return xmlStrEqual(ns->href, xml_value) ? S_OK : E_INVALIDARG;
1291     }
1292
1293     if (!xmlSetNsProp(element, NULL, xml_name, xml_value))
1294         hr = E_FAIL;
1295
1296     heap_free(xml_value);
1297     heap_free(xml_name);
1298
1299     return hr;
1300 }
1301
1302 static HRESULT WINAPI domelem_removeAttribute(
1303     IXMLDOMElement *iface,
1304     BSTR p)
1305 {
1306     domelem *This = impl_from_IXMLDOMElement( iface );
1307     IXMLDOMNamedNodeMap *attr;
1308     HRESULT hr;
1309
1310     TRACE("(%p)->(%s)\n", This, debugstr_w(p));
1311
1312     hr = IXMLDOMElement_get_attributes(iface, &attr);
1313     if (hr != S_OK) return hr;
1314
1315     hr = IXMLDOMNamedNodeMap_removeNamedItem(attr, p, NULL);
1316     IXMLDOMNamedNodeMap_Release(attr);
1317
1318     return hr;
1319 }
1320
1321 static HRESULT WINAPI domelem_getAttributeNode(
1322     IXMLDOMElement *iface,
1323     BSTR p, IXMLDOMAttribute** attributeNode )
1324 {
1325     domelem *This = impl_from_IXMLDOMElement( iface );
1326     xmlChar *local, *prefix, *nameA;
1327     HRESULT hr = S_FALSE;
1328     xmlNodePtr element;
1329     xmlAttrPtr attr;
1330
1331     TRACE("(%p)->(%s %p)\n", This, debugstr_w(p), attributeNode);
1332
1333     element = get_element( This );
1334     if (!element) return E_FAIL;
1335
1336     if (attributeNode) *attributeNode = NULL;
1337
1338     nameA = xmlchar_from_wchar(p);
1339     if (!xmlValidateNameValue(nameA))
1340     {
1341         heap_free(nameA);
1342         return E_FAIL;
1343     }
1344
1345     if (!attributeNode)
1346     {
1347         heap_free(nameA);
1348         return S_FALSE;
1349     }
1350
1351     *attributeNode = NULL;
1352
1353     local = xmlSplitQName2(nameA, &prefix);
1354
1355     if (local)
1356     {
1357         /* try to get namespace for supplied qualified name */
1358         xmlNsPtr ns = xmlSearchNs(element->doc, element, prefix);
1359         xmlFree(prefix);
1360
1361         attr = xmlHasNsProp(element, local, ns ? ns->href : NULL);
1362         xmlFree(local);
1363     }
1364     else
1365     {
1366         attr = xmlHasProp(element, nameA);
1367         /* attribute has attached namespace and we requested non-qualified
1368            name - it's a failure case */
1369         if (attr && attr->ns) attr = NULL;
1370     }
1371
1372     heap_free(nameA);
1373
1374     if (attr)
1375     {
1376         IUnknown *unk = create_attribute((xmlNodePtr)attr);
1377         hr = IUnknown_QueryInterface(unk, &IID_IXMLDOMAttribute, (void**)attributeNode);
1378         IUnknown_Release(unk);
1379     }
1380
1381     return hr;
1382 }
1383
1384 static HRESULT WINAPI domelem_setAttributeNode(
1385     IXMLDOMElement *iface,
1386     IXMLDOMAttribute* attribute,
1387     IXMLDOMAttribute** old)
1388 {
1389     domelem *This = impl_from_IXMLDOMElement( iface );
1390     static const WCHAR xmlnsW[] = {'x','m','l','n','s',0};
1391     xmlChar *name, *value;
1392     BSTR nameW, prefix;
1393     xmlnode *attr_node;
1394     xmlAttrPtr attr;
1395     VARIANT valueW;
1396     HRESULT hr;
1397
1398     FIXME("(%p)->(%p %p): semi-stub\n", This, attribute, old);
1399
1400     if (!attribute) return E_INVALIDARG;
1401
1402     attr_node = get_node_obj((IXMLDOMNode*)attribute);
1403     if (!attr_node) return E_FAIL;
1404
1405     if (attr_node->parent)
1406     {
1407         WARN("attempt to add already used attribute\n");
1408         return E_FAIL;
1409     }
1410
1411     hr = IXMLDOMAttribute_get_nodeName(attribute, &nameW);
1412     if (hr != S_OK) return hr;
1413
1414     /* adding xmlns attribute doesn't change a tree or existing namespace definition */
1415     if (!strcmpW(nameW, xmlnsW))
1416     {
1417         SysFreeString(nameW);
1418         return DISP_E_UNKNOWNNAME;
1419     }
1420
1421     hr = IXMLDOMAttribute_get_nodeValue(attribute, &valueW);
1422     if (hr != S_OK)
1423     {
1424         SysFreeString(nameW);
1425         return hr;
1426     }
1427
1428     if (old) *old = NULL;
1429
1430     TRACE("attribute: %s=%s\n", debugstr_w(nameW), debugstr_w(V_BSTR(&valueW)));
1431
1432     hr = IXMLDOMAttribute_get_prefix(attribute, &prefix);
1433     if (hr == S_OK)
1434     {
1435         FIXME("namespaces not supported: %s\n", debugstr_w(prefix));
1436         SysFreeString(prefix);
1437     }
1438
1439     name = xmlchar_from_wchar(nameW);
1440     value = xmlchar_from_wchar(V_BSTR(&valueW));
1441
1442     if (!name || !value)
1443     {
1444         SysFreeString(nameW);
1445         VariantClear(&valueW);
1446         heap_free(name);
1447         heap_free(value);
1448         return E_OUTOFMEMORY;
1449     }
1450
1451     attr = xmlSetNsProp(get_element(This), NULL, name, value);
1452     if (attr)
1453         attr_node->parent = (IXMLDOMNode*)iface;
1454
1455     SysFreeString(nameW);
1456     VariantClear(&valueW);
1457     heap_free(name);
1458     heap_free(value);
1459
1460     return attr ? S_OK : E_FAIL;
1461 }
1462
1463 static HRESULT WINAPI domelem_removeAttributeNode(
1464     IXMLDOMElement *iface,
1465     IXMLDOMAttribute* domAttribute,
1466     IXMLDOMAttribute** attributeNode)
1467 {
1468     domelem *This = impl_from_IXMLDOMElement( iface );
1469     FIXME("(%p)->(%p %p)\n", This, domAttribute, attributeNode);
1470     return E_NOTIMPL;
1471 }
1472
1473 static HRESULT WINAPI domelem_getElementsByTagName(
1474     IXMLDOMElement *iface,
1475     BSTR tagName, IXMLDOMNodeList** resultList)
1476 {
1477     domelem *This = impl_from_IXMLDOMElement( iface );
1478     xmlChar *query;
1479     HRESULT hr;
1480     BOOL XPath;
1481
1482     TRACE("(%p)->(%s, %p)\n", This, debugstr_w(tagName), resultList);
1483
1484     if (!tagName || !resultList) return E_INVALIDARG;
1485
1486     XPath = is_xpathmode(get_element(This)->doc);
1487     set_xpathmode(get_element(This)->doc, TRUE);
1488     query = tagName_to_XPath(tagName);
1489     hr = create_selection(get_element(This), query, resultList);
1490     xmlFree(query);
1491     set_xpathmode(get_element(This)->doc, XPath);
1492
1493     return hr;
1494 }
1495
1496 static HRESULT WINAPI domelem_normalize(
1497     IXMLDOMElement *iface )
1498 {
1499     domelem *This = impl_from_IXMLDOMElement( iface );
1500     FIXME("%p\n", This);
1501     return E_NOTIMPL;
1502 }
1503
1504 static const struct IXMLDOMElementVtbl domelem_vtbl =
1505 {
1506     domelem_QueryInterface,
1507     domelem_AddRef,
1508     domelem_Release,
1509     domelem_GetTypeInfoCount,
1510     domelem_GetTypeInfo,
1511     domelem_GetIDsOfNames,
1512     domelem_Invoke,
1513     domelem_get_nodeName,
1514     domelem_get_nodeValue,
1515     domelem_put_nodeValue,
1516     domelem_get_nodeType,
1517     domelem_get_parentNode,
1518     domelem_get_childNodes,
1519     domelem_get_firstChild,
1520     domelem_get_lastChild,
1521     domelem_get_previousSibling,
1522     domelem_get_nextSibling,
1523     domelem_get_attributes,
1524     domelem_insertBefore,
1525     domelem_replaceChild,
1526     domelem_removeChild,
1527     domelem_appendChild,
1528     domelem_hasChildNodes,
1529     domelem_get_ownerDocument,
1530     domelem_cloneNode,
1531     domelem_get_nodeTypeString,
1532     domelem_get_text,
1533     domelem_put_text,
1534     domelem_get_specified,
1535     domelem_get_definition,
1536     domelem_get_nodeTypedValue,
1537     domelem_put_nodeTypedValue,
1538     domelem_get_dataType,
1539     domelem_put_dataType,
1540     domelem_get_xml,
1541     domelem_transformNode,
1542     domelem_selectNodes,
1543     domelem_selectSingleNode,
1544     domelem_get_parsed,
1545     domelem_get_namespaceURI,
1546     domelem_get_prefix,
1547     domelem_get_baseName,
1548     domelem_transformNodeToObject,
1549     domelem_get_tagName,
1550     domelem_getAttribute,
1551     domelem_setAttribute,
1552     domelem_removeAttribute,
1553     domelem_getAttributeNode,
1554     domelem_setAttributeNode,
1555     domelem_removeAttributeNode,
1556     domelem_getElementsByTagName,
1557     domelem_normalize,
1558 };
1559
1560 static HRESULT domelem_get_qualified_item(const xmlNodePtr node, BSTR name, BSTR uri,
1561     IXMLDOMNode **item)
1562 {
1563     xmlAttrPtr attr;
1564     xmlChar *nameA;
1565     xmlChar *href;
1566
1567     TRACE("(%p)->(%s %s %p)\n", node, debugstr_w(name), debugstr_w(uri), item);
1568
1569     if (!name || !item) return E_INVALIDARG;
1570
1571     if (uri && *uri)
1572     {
1573         href = xmlchar_from_wchar(uri);
1574         if (!href) return E_OUTOFMEMORY;
1575     }
1576     else
1577         href = NULL;
1578
1579     nameA = xmlchar_from_wchar(name);
1580     if (!nameA)
1581     {
1582         heap_free(href);
1583         return E_OUTOFMEMORY;
1584     }
1585
1586     attr = xmlHasNsProp(node, nameA, href);
1587
1588     heap_free(nameA);
1589     heap_free(href);
1590
1591     if (!attr)
1592     {
1593         *item = NULL;
1594         return S_FALSE;
1595     }
1596
1597     *item = create_node((xmlNodePtr)attr);
1598
1599     return S_OK;
1600 }
1601
1602 static HRESULT domelem_get_named_item(const xmlNodePtr node, BSTR name, IXMLDOMNode **item)
1603 {
1604     xmlChar *nameA, *local, *prefix;
1605     BSTR uriW, localW;
1606     xmlNsPtr ns;
1607     HRESULT hr;
1608
1609     TRACE("(%p)->(%s %p)\n", node, debugstr_w(name), item );
1610
1611     nameA = xmlchar_from_wchar(name);
1612     local = xmlSplitQName2(nameA, &prefix);
1613     heap_free(nameA);
1614
1615     if (!local)
1616         return domelem_get_qualified_item(node, name, NULL, item);
1617
1618     /* try to get namespace uri for supplied qualified name */
1619     ns = xmlSearchNs(node->doc, node, prefix);
1620
1621     xmlFree(prefix);
1622
1623     if (!ns)
1624     {
1625         xmlFree(local);
1626         if (item) *item = NULL;
1627         return item ? S_FALSE : E_INVALIDARG;
1628     }
1629
1630     uriW = bstr_from_xmlChar(ns->href);
1631     localW = bstr_from_xmlChar(local);
1632     xmlFree(local);
1633
1634     TRACE("got qualified node %s, uri=%s\n", debugstr_w(localW), debugstr_w(uriW));
1635
1636     hr = domelem_get_qualified_item(node, localW, uriW, item);
1637
1638     SysFreeString(localW);
1639     SysFreeString(uriW);
1640
1641     return hr;
1642 }
1643
1644 static HRESULT domelem_set_named_item(xmlNodePtr node, IXMLDOMNode *newItem, IXMLDOMNode **namedItem)
1645 {
1646     xmlNodePtr nodeNew;
1647     xmlnode *ThisNew;
1648
1649     TRACE("(%p)->(%p %p)\n", node, newItem, namedItem );
1650
1651     if(!newItem)
1652         return E_INVALIDARG;
1653
1654     if(namedItem) *namedItem = NULL;
1655
1656     /* Must be an Attribute */
1657     ThisNew = get_node_obj( newItem );
1658     if(!ThisNew) return E_FAIL;
1659
1660     if(ThisNew->node->type != XML_ATTRIBUTE_NODE)
1661         return E_FAIL;
1662
1663     if(!ThisNew->node->parent)
1664         if(xmldoc_remove_orphan(ThisNew->node->doc, ThisNew->node) != S_OK)
1665             WARN("%p is not an orphan of %p\n", ThisNew->node, ThisNew->node->doc);
1666
1667     nodeNew = xmlAddChild(node, ThisNew->node);
1668
1669     if(namedItem)
1670         *namedItem = create_node( nodeNew );
1671     return S_OK;
1672 }
1673
1674 static HRESULT domelem_remove_qualified_item(xmlNodePtr node, BSTR name, BSTR uri, IXMLDOMNode **item)
1675 {
1676     xmlChar *nameA, *href;
1677     xmlAttrPtr attr;
1678
1679     TRACE("(%p)->(%s %s %p)\n", node, debugstr_w(name), debugstr_w(uri), item);
1680
1681     if (!name) return E_INVALIDARG;
1682
1683     if (uri && *uri)
1684     {
1685         href = xmlchar_from_wchar(uri);
1686         if (!href) return E_OUTOFMEMORY;
1687     }
1688     else
1689         href = NULL;
1690
1691     nameA = xmlchar_from_wchar(name);
1692     if (!nameA)
1693     {
1694         heap_free(href);
1695         return E_OUTOFMEMORY;
1696     }
1697
1698     attr = xmlHasNsProp(node, nameA, href);
1699
1700     heap_free(nameA);
1701     heap_free(href);
1702
1703     if (!attr)
1704     {
1705         if (item) *item = NULL;
1706         return S_FALSE;
1707     }
1708
1709     if (item)
1710     {
1711         xmlUnlinkNode( (xmlNodePtr) attr );
1712         xmldoc_add_orphan( attr->doc, (xmlNodePtr) attr );
1713         *item = create_node( (xmlNodePtr) attr );
1714     }
1715     else
1716     {
1717         if (xmlRemoveProp(attr) == -1)
1718             ERR("xmlRemoveProp failed\n");
1719     }
1720
1721     return S_OK;
1722 }
1723
1724 static HRESULT domelem_remove_named_item(xmlNodePtr node, BSTR name, IXMLDOMNode **item)
1725 {
1726     TRACE("(%p)->(%s %p)\n", node, debugstr_w(name), item);
1727     return domelem_remove_qualified_item(node, name, NULL, item);
1728 }
1729
1730 static HRESULT domelem_get_item(const xmlNodePtr node, LONG index, IXMLDOMNode **item)
1731 {
1732     xmlAttrPtr curr;
1733     LONG attrIndex;
1734
1735     TRACE("(%p)->(%d %p)\n", node, index, item);
1736
1737     *item = NULL;
1738
1739     if (index < 0)
1740         return S_FALSE;
1741
1742     curr = node->properties;
1743
1744     for (attrIndex = 0; attrIndex < index; attrIndex++) {
1745         if (curr->next == NULL)
1746             return S_FALSE;
1747         else
1748             curr = curr->next;
1749     }
1750
1751     *item = create_node( (xmlNodePtr) curr );
1752
1753     return S_OK;
1754 }
1755
1756 static HRESULT domelem_get_length(const xmlNodePtr node, LONG *length)
1757 {
1758     xmlAttrPtr first;
1759     xmlAttrPtr curr;
1760     LONG attrCount;
1761
1762     TRACE("(%p)->(%p)\n", node, length);
1763
1764     if( !length )
1765         return E_INVALIDARG;
1766
1767     first = node->properties;
1768     if (first == NULL) {
1769         *length = 0;
1770         return S_OK;
1771     }
1772
1773     curr = first;
1774     attrCount = 1;
1775     while (curr->next) {
1776         attrCount++;
1777         curr = curr->next;
1778     }
1779     *length = attrCount;
1780
1781     return S_OK;
1782 }
1783
1784 static HRESULT domelem_next_node(const xmlNodePtr node, LONG *iter, IXMLDOMNode **nextNode)
1785 {
1786     xmlAttrPtr curr;
1787     LONG i;
1788
1789     TRACE("(%p)->(%d: %p)\n", node, *iter, nextNode);
1790
1791     *nextNode = NULL;
1792
1793     curr = node->properties;
1794
1795     for (i = 0; i < *iter; i++) {
1796         if (curr->next == NULL)
1797             return S_FALSE;
1798         else
1799             curr = curr->next;
1800     }
1801
1802     (*iter)++;
1803     *nextNode = create_node((xmlNodePtr)curr);
1804
1805     return S_OK;
1806 }
1807
1808 static const struct nodemap_funcs domelem_attr_map = {
1809     domelem_get_named_item,
1810     domelem_set_named_item,
1811     domelem_remove_named_item,
1812     domelem_get_item,
1813     domelem_get_length,
1814     domelem_get_qualified_item,
1815     domelem_remove_qualified_item,
1816     domelem_next_node
1817 };
1818
1819 static const tid_t domelem_iface_tids[] = {
1820     IXMLDOMElement_tid,
1821     0
1822 };
1823
1824 static dispex_static_data_t domelem_dispex = {
1825     NULL,
1826     IXMLDOMElement_tid,
1827     NULL,
1828     domelem_iface_tids
1829 };
1830
1831 IUnknown* create_element( xmlNodePtr element )
1832 {
1833     domelem *This;
1834
1835     This = heap_alloc( sizeof *This );
1836     if ( !This )
1837         return NULL;
1838
1839     This->IXMLDOMElement_iface.lpVtbl = &domelem_vtbl;
1840     This->ref = 1;
1841
1842     init_xmlnode(&This->node, element, (IXMLDOMNode*)&This->IXMLDOMElement_iface, &domelem_dispex);
1843
1844     return (IUnknown*)&This->IXMLDOMElement_iface;
1845 }
1846
1847 #endif