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