ext/win32ole/sample/xml.rb

DEFINITIONS

   1  # 
   2  # This file created by olegen.rb as following.
   3  #    ruby olegen.rb 'Microsoft XML, version 2.0' > xml.rb
   4  # 
   5  require 'win32ole'
   6  require 'win32ole/property'
   7  
   8  # 
   9  module IXMLDOMImplementation
  10    include WIN32OLE::VARIANT
  11    attr_reader :lastargs
  12  
  13    # BOOL hasFeature
  14    #   BSTR arg0 --- feature [IN]
  15    #   BSTR arg1 --- version [IN]
  16    def hasFeature(arg0, arg1)
  17      ret = _invoke(145, [arg0, arg1], [VT_BSTR, VT_BSTR])
  18      @lastargs = WIN32OLE::ARGV
  19      ret
  20    end
  21  end
  22  
  23  # Core DOM node interface
  24  module IXMLDOMNode
  25    include WIN32OLE::VARIANT
  26    attr_reader :lastargs
  27  
  28    # BSTR nodeName
  29    # name of the node
  30    def nodeName()
  31      ret = _getproperty(2, [], [])
  32      @lastargs = WIN32OLE::ARGV
  33      ret
  34    end
  35  
  36    # VARIANT nodeValue
  37    # value stored in the node
  38    def nodeValue()
  39      ret = _getproperty(3, [], [])
  40      @lastargs = WIN32OLE::ARGV
  41      ret
  42    end
  43  
  44    # DOMNodeType nodeType
  45    # the node's type
  46    def nodeType()
  47      ret = _getproperty(4, [], [])
  48      @lastargs = WIN32OLE::ARGV
  49      ret
  50    end
  51  
  52    # IXMLDOMNode parentNode
  53    # parent of the node
  54    def parentNode()
  55      ret = _getproperty(6, [], [])
  56      @lastargs = WIN32OLE::ARGV
  57      ret
  58    end
  59  
  60    # IXMLDOMNodeList childNodes
  61    # the collection of the node's children
  62    def childNodes()
  63      ret = _getproperty(7, [], [])
  64      @lastargs = WIN32OLE::ARGV
  65      ret
  66    end
  67  
  68    # IXMLDOMNode firstChild
  69    # first child of the node
  70    def firstChild()
  71      ret = _getproperty(8, [], [])
  72      @lastargs = WIN32OLE::ARGV
  73      ret
  74    end
  75  
  76    # IXMLDOMNode lastChild
  77    # first child of the node
  78    def lastChild()
  79      ret = _getproperty(9, [], [])
  80      @lastargs = WIN32OLE::ARGV
  81      ret
  82    end
  83  
  84    # IXMLDOMNode previousSibling
  85    # left sibling of the node
  86    def previousSibling()
  87      ret = _getproperty(10, [], [])
  88      @lastargs = WIN32OLE::ARGV
  89      ret
  90    end
  91  
  92    # IXMLDOMNode nextSibling
  93    # right sibling of the node
  94    def nextSibling()
  95      ret = _getproperty(11, [], [])
  96      @lastargs = WIN32OLE::ARGV
  97      ret
  98    end
  99  
 100    # IXMLDOMNamedNodeMap attributes
 101    # the collection of the node's attributes
 102    def attributes()
 103      ret = _getproperty(12, [], [])
 104      @lastargs = WIN32OLE::ARGV
 105      ret
 106    end
 107  
 108    # IXMLDOMDocument ownerDocument
 109    # document that contains the node
 110    def ownerDocument()
 111      ret = _getproperty(18, [], [])
 112      @lastargs = WIN32OLE::ARGV
 113      ret
 114    end
 115  
 116    # BSTR nodeTypeString
 117    # the type of node in string form
 118    def nodeTypeString()
 119      ret = _getproperty(21, [], [])
 120      @lastargs = WIN32OLE::ARGV
 121      ret
 122    end
 123  
 124    # BSTR text
 125    # text content of the node and subtree
 126    def text()
 127      ret = _getproperty(24, [], [])
 128      @lastargs = WIN32OLE::ARGV
 129      ret
 130    end
 131  
 132    # BOOL specified
 133    # indicates whether node is a default value
 134    def specified()
 135      ret = _getproperty(22, [], [])
 136      @lastargs = WIN32OLE::ARGV
 137      ret
 138    end
 139  
 140    # IXMLDOMNode definition
 141    # pointer to the definition of the node in the DTD or schema
 142    def definition()
 143      ret = _getproperty(23, [], [])
 144      @lastargs = WIN32OLE::ARGV
 145      ret
 146    end
 147  
 148    # VARIANT nodeTypedValue
 149    # get the strongly typed value of the node
 150    def nodeTypedValue()
 151      ret = _getproperty(25, [], [])
 152      @lastargs = WIN32OLE::ARGV
 153      ret
 154    end
 155  
 156    # VARIANT dataType
 157    # the data type of the node
 158    def dataType()
 159      ret = _getproperty(26, [], [])
 160      @lastargs = WIN32OLE::ARGV
 161      ret
 162    end
 163  
 164    # BSTR xml
 165    # return the XML source for the node and each of its descendants
 166    def xml()
 167      ret = _getproperty(27, [], [])
 168      @lastargs = WIN32OLE::ARGV
 169      ret
 170    end
 171  
 172    # BOOL parsed
 173    # has sub-tree been completely parsed
 174    def parsed()
 175      ret = _getproperty(31, [], [])
 176      @lastargs = WIN32OLE::ARGV
 177      ret
 178    end
 179  
 180    # BSTR namespaceURI
 181    # the URI for the namespace applying to the node
 182    def namespaceURI()
 183      ret = _getproperty(32, [], [])
 184      @lastargs = WIN32OLE::ARGV
 185      ret
 186    end
 187  
 188    # BSTR prefix
 189    # the prefix for the namespace applying to the node
 190    def prefix()
 191      ret = _getproperty(33, [], [])
 192      @lastargs = WIN32OLE::ARGV
 193      ret
 194    end
 195  
 196    # BSTR baseName
 197    # the base name of the node (nodename with the prefix stripped off)
 198    def baseName()
 199      ret = _getproperty(34, [], [])
 200      @lastargs = WIN32OLE::ARGV
 201      ret
 202    end
 203  
 204    # VOID nodeValue
 205    # value stored in the node
 206    def nodeValue=(arg0)
 207      ret = _setproperty(3, [arg0], [VT_VARIANT])
 208      @lastargs = WIN32OLE::ARGV
 209      ret
 210    end
 211  
 212    # VOID text
 213    # text content of the node and subtree
 214    def text=(arg0)
 215      ret = _setproperty(24, [arg0], [VT_BSTR])
 216      @lastargs = WIN32OLE::ARGV
 217      ret
 218    end
 219  
 220    # VOID nodeTypedValue
 221    # get the strongly typed value of the node
 222    def nodeTypedValue=(arg0)
 223      ret = _setproperty(25, [arg0], [VT_VARIANT])
 224      @lastargs = WIN32OLE::ARGV
 225      ret
 226    end
 227  
 228    # VOID dataType
 229    # the data type of the node
 230    def dataType=(arg0)
 231      ret = _setproperty(26, [arg0], [VT_VARIANT])
 232      @lastargs = WIN32OLE::ARGV
 233      ret
 234    end
 235  
 236    # IXMLDOMNode insertBefore
 237    # insert a child node
 238    #   IXMLDOMNode arg0 --- newChild [IN]
 239    #   VARIANT arg1 --- refChild [IN]
 240    def insertBefore(arg0, arg1)
 241      ret = _invoke(13, [arg0, arg1], [VT_BYREF|VT_DISPATCH, VT_VARIANT])
 242      @lastargs = WIN32OLE::ARGV
 243      ret
 244    end
 245  
 246    # IXMLDOMNode replaceChild
 247    # replace a child node
 248    #   IXMLDOMNode arg0 --- newChild [IN]
 249    #   IXMLDOMNode arg1 --- oldChild [IN]
 250    def replaceChild(arg0, arg1)
 251      ret = _invoke(14, [arg0, arg1], [VT_BYREF|VT_DISPATCH, VT_BYREF|VT_DISPATCH])
 252      @lastargs = WIN32OLE::ARGV
 253      ret
 254    end
 255  
 256    # IXMLDOMNode removeChild
 257    # remove a child node
 258    #   IXMLDOMNode arg0 --- childNode [IN]
 259    def removeChild(arg0)
 260      ret = _invoke(15, [arg0], [VT_BYREF|VT_DISPATCH])
 261      @lastargs = WIN32OLE::ARGV
 262      ret
 263    end
 264  
 265    # IXMLDOMNode appendChild
 266    # append a child node
 267    #   IXMLDOMNode arg0 --- newChild [IN]
 268    def appendChild(arg0)
 269      ret = _invoke(16, [arg0], [VT_BYREF|VT_DISPATCH])
 270      @lastargs = WIN32OLE::ARGV
 271      ret
 272    end
 273  
 274    # BOOL hasChildNodes
 275    def hasChildNodes()
 276      ret = _invoke(17, [], [])
 277      @lastargs = WIN32OLE::ARGV
 278      ret
 279    end
 280  
 281    # IXMLDOMNode cloneNode
 282    #   BOOL arg0 --- deep [IN]
 283    def cloneNode(arg0)
 284      ret = _invoke(19, [arg0], [VT_BOOL])
 285      @lastargs = WIN32OLE::ARGV
 286      ret
 287    end
 288  
 289    # BSTR transformNode
 290    # apply the stylesheet to the subtree
 291    #   IXMLDOMNode arg0 --- stylesheet [IN]
 292    def transformNode(arg0)
 293      ret = _invoke(28, [arg0], [VT_BYREF|VT_DISPATCH])
 294      @lastargs = WIN32OLE::ARGV
 295      ret
 296    end
 297  
 298    # IXMLDOMNodeList selectNodes
 299    # execute query on the subtree
 300    #   BSTR arg0 --- queryString [IN]
 301    def selectNodes(arg0)
 302      ret = _invoke(29, [arg0], [VT_BSTR])
 303      @lastargs = WIN32OLE::ARGV
 304      ret
 305    end
 306  
 307    # IXMLDOMNode selectSingleNode
 308    # execute query on the subtree
 309    #   BSTR arg0 --- queryString [IN]
 310    def selectSingleNode(arg0)
 311      ret = _invoke(30, [arg0], [VT_BSTR])
 312      @lastargs = WIN32OLE::ARGV
 313      ret
 314    end
 315  
 316    # VOID transformNodeToObject
 317    # apply the stylesheet to the subtree, returning the result through a document or a stream
 318    #   IXMLDOMNode arg0 --- stylesheet [IN]
 319    #   VARIANT arg1 --- outputObject [IN]
 320    def transformNodeToObject(arg0, arg1)
 321      ret = _invoke(35, [arg0, arg1], [VT_BYREF|VT_DISPATCH, VT_VARIANT])
 322      @lastargs = WIN32OLE::ARGV
 323      ret
 324    end
 325  end
 326  
 327  # Constants that define a node's type
 328  module OLEtagDOMNodeType
 329    include WIN32OLE::VARIANT
 330    attr_reader :lastargs
 331    NODE_INVALID = 0
 332    NODE_ELEMENT = 1
 333    NODE_ATTRIBUTE = 2
 334    NODE_TEXT = 3
 335    NODE_CDATA_SECTION = 4
 336    NODE_ENTITY_REFERENCE = 5
 337    NODE_ENTITY = 6
 338    NODE_PROCESSING_INSTRUCTION = 7
 339    NODE_COMMENT = 8
 340    NODE_DOCUMENT = 9
 341    NODE_DOCUMENT_TYPE = 10
 342    NODE_DOCUMENT_FRAGMENT = 11
 343    NODE_NOTATION = 12
 344  end
 345  
 346  # 
 347  module IXMLDOMNodeList
 348    include WIN32OLE::VARIANT
 349    attr_reader :lastargs
 350  
 351    # I4 length
 352    # number of nodes in the collection
 353    def length()
 354      ret = _getproperty(74, [], [])
 355      @lastargs = WIN32OLE::ARGV
 356      ret
 357    end
 358  
 359    # PTR item
 360    # collection of nodes
 361    #   I4 arg0 --- index [IN]
 362    def item
 363      OLEProperty.new(self, 0, [VT_I4], [VT_I4, VT_BYREF|VT_DISPATCH])
 364    end
 365  
 366    # IXMLDOMNode nextNode
 367    # get next node from iterator
 368    def nextNode()
 369      ret = _invoke(76, [], [])
 370      @lastargs = WIN32OLE::ARGV
 371      ret
 372    end
 373  
 374    # VOID reset
 375    # reset the position of iterator
 376    def reset()
 377      ret = _invoke(77, [], [])
 378      @lastargs = WIN32OLE::ARGV
 379      ret
 380    end
 381  end
 382  
 383  # 
 384  module IXMLDOMNamedNodeMap
 385    include WIN32OLE::VARIANT
 386    attr_reader :lastargs
 387  
 388    # I4 length
 389    # number of nodes in the collection
 390    def length()
 391      ret = _getproperty(74, [], [])
 392      @lastargs = WIN32OLE::ARGV
 393      ret
 394    end
 395  
 396    # PTR item
 397    # collection of nodes
 398    #   I4 arg0 --- index [IN]
 399    def item
 400      OLEProperty.new(self, 0, [VT_I4], [VT_I4, VT_BYREF|VT_DISPATCH])
 401    end
 402  
 403    # IXMLDOMNode getNamedItem
 404    # lookup item by name
 405    #   BSTR arg0 --- name [IN]
 406    def getNamedItem(arg0)
 407      ret = _invoke(83, [arg0], [VT_BSTR])
 408      @lastargs = WIN32OLE::ARGV
 409      ret
 410    end
 411  
 412    # IXMLDOMNode setNamedItem
 413    # set item by name
 414    #   IXMLDOMNode arg0 --- newItem [IN]
 415    def setNamedItem(arg0)
 416      ret = _invoke(84, [arg0], [VT_BYREF|VT_DISPATCH])
 417      @lastargs = WIN32OLE::ARGV
 418      ret
 419    end
 420  
 421    # IXMLDOMNode removeNamedItem
 422    # remove item by name
 423    #   BSTR arg0 --- name [IN]
 424    def removeNamedItem(arg0)
 425      ret = _invoke(85, [arg0], [VT_BSTR])
 426      @lastargs = WIN32OLE::ARGV
 427      ret
 428    end
 429  
 430    # IXMLDOMNode getQualifiedItem
 431    # lookup the item by name and namespace
 432    #   BSTR arg0 --- baseName [IN]
 433    #   BSTR arg1 --- namespaceURI [IN]
 434    def getQualifiedItem(arg0, arg1)
 435      ret = _invoke(87, [arg0, arg1], [VT_BSTR, VT_BSTR])
 436      @lastargs = WIN32OLE::ARGV
 437      ret
 438    end
 439  
 440    # IXMLDOMNode removeQualifiedItem
 441    # remove the item by name and namespace
 442    #   BSTR arg0 --- baseName [IN]
 443    #   BSTR arg1 --- namespaceURI [IN]
 444    def removeQualifiedItem(arg0, arg1)
 445      ret = _invoke(88, [arg0, arg1], [VT_BSTR, VT_BSTR])
 446      @lastargs = WIN32OLE::ARGV
 447      ret
 448    end
 449  
 450    # IXMLDOMNode nextNode
 451    # get next node from iterator
 452    def nextNode()
 453      ret = _invoke(89, [], [])
 454      @lastargs = WIN32OLE::ARGV
 455      ret
 456    end
 457  
 458    # VOID reset
 459    # reset the position of iterator
 460    def reset()
 461      ret = _invoke(90, [], [])
 462      @lastargs = WIN32OLE::ARGV
 463      ret
 464    end
 465  end
 466  
 467  # 
 468  module IXMLDOMDocument
 469    include WIN32OLE::VARIANT
 470    attr_reader :lastargs
 471  
 472    # BSTR nodeName
 473    # name of the node
 474    def nodeName()
 475      ret = _getproperty(2, [], [])
 476      @lastargs = WIN32OLE::ARGV
 477      ret
 478    end
 479  
 480    # VARIANT nodeValue
 481    # value stored in the node
 482    def nodeValue()
 483      ret = _getproperty(3, [], [])
 484      @lastargs = WIN32OLE::ARGV
 485      ret
 486    end
 487  
 488    # DOMNodeType nodeType
 489    # the node's type
 490    def nodeType()
 491      ret = _getproperty(4, [], [])
 492      @lastargs = WIN32OLE::ARGV
 493      ret
 494    end
 495  
 496    # IXMLDOMNode parentNode
 497    # parent of the node
 498    def parentNode()
 499      ret = _getproperty(6, [], [])
 500      @lastargs = WIN32OLE::ARGV
 501      ret
 502    end
 503  
 504    # IXMLDOMNodeList childNodes
 505    # the collection of the node's children
 506    def childNodes()
 507      ret = _getproperty(7, [], [])
 508      @lastargs = WIN32OLE::ARGV
 509      ret
 510    end
 511  
 512    # IXMLDOMNode firstChild
 513    # first child of the node
 514    def firstChild()
 515      ret = _getproperty(8, [], [])
 516      @lastargs = WIN32OLE::ARGV
 517      ret
 518    end
 519  
 520    # IXMLDOMNode lastChild
 521    # first child of the node
 522    def lastChild()
 523      ret = _getproperty(9, [], [])
 524      @lastargs = WIN32OLE::ARGV
 525      ret
 526    end
 527  
 528    # IXMLDOMNode previousSibling
 529    # left sibling of the node
 530    def previousSibling()
 531      ret = _getproperty(10, [], [])
 532      @lastargs = WIN32OLE::ARGV
 533      ret
 534    end
 535  
 536    # IXMLDOMNode nextSibling
 537    # right sibling of the node
 538    def nextSibling()
 539      ret = _getproperty(11, [], [])
 540      @lastargs = WIN32OLE::ARGV
 541      ret
 542    end
 543  
 544    # IXMLDOMNamedNodeMap attributes
 545    # the collection of the node's attributes
 546    def attributes()
 547      ret = _getproperty(12, [], [])
 548      @lastargs = WIN32OLE::ARGV
 549      ret
 550    end
 551  
 552    # IXMLDOMDocument ownerDocument
 553    # document that contains the node
 554    def ownerDocument()
 555      ret = _getproperty(18, [], [])
 556      @lastargs = WIN32OLE::ARGV
 557      ret
 558    end
 559  
 560    # BSTR nodeTypeString
 561    # the type of node in string form
 562    def nodeTypeString()
 563      ret = _getproperty(21, [], [])
 564      @lastargs = WIN32OLE::ARGV
 565      ret
 566    end
 567  
 568    # BSTR text
 569    # text content of the node and subtree
 570    def text()
 571      ret = _getproperty(24, [], [])
 572      @lastargs = WIN32OLE::ARGV
 573      ret
 574    end
 575  
 576    # BOOL specified
 577    # indicates whether node is a default value
 578    def specified()
 579      ret = _getproperty(22, [], [])
 580      @lastargs = WIN32OLE::ARGV
 581      ret
 582    end
 583  
 584    # IXMLDOMNode definition
 585    # pointer to the definition of the node in the DTD or schema
 586    def definition()
 587      ret = _getproperty(23, [], [])
 588      @lastargs = WIN32OLE::ARGV
 589      ret
 590    end
 591  
 592    # VARIANT nodeTypedValue
 593    # get the strongly typed value of the node
 594    def nodeTypedValue()
 595      ret = _getproperty(25, [], [])
 596      @lastargs = WIN32OLE::ARGV
 597      ret
 598    end
 599  
 600    # VARIANT dataType
 601    # the data type of the node
 602    def dataType()
 603      ret = _getproperty(26, [], [])
 604      @lastargs = WIN32OLE::ARGV
 605      ret
 606    end
 607  
 608    # BSTR xml
 609    # return the XML source for the node and each of its descendants
 610    def xml()
 611      ret = _getproperty(27, [], [])
 612      @lastargs = WIN32OLE::ARGV
 613      ret
 614    end
 615  
 616    # BOOL parsed
 617    # has sub-tree been completely parsed
 618    def parsed()
 619      ret = _getproperty(31, [], [])
 620      @lastargs = WIN32OLE::ARGV
 621      ret
 622    end
 623  
 624    # BSTR namespaceURI
 625    # the URI for the namespace applying to the node
 626    def namespaceURI()
 627      ret = _getproperty(32, [], [])
 628      @lastargs = WIN32OLE::ARGV
 629      ret
 630    end
 631  
 632    # BSTR prefix
 633    # the prefix for the namespace applying to the node
 634    def prefix()
 635      ret = _getproperty(33, [], [])
 636      @lastargs = WIN32OLE::ARGV
 637      ret
 638    end
 639  
 640    # BSTR baseName
 641    # the base name of the node (nodename with the prefix stripped off)
 642    def baseName()
 643      ret = _getproperty(34, [], [])
 644      @lastargs = WIN32OLE::ARGV
 645      ret
 646    end
 647  
 648    # IXMLDOMDocumentType doctype
 649    # node corresponding to the DOCTYPE
 650    def doctype()
 651      ret = _getproperty(38, [], [])
 652      @lastargs = WIN32OLE::ARGV
 653      ret
 654    end
 655  
 656    # IXMLDOMImplementation implementation
 657    # info on this DOM implementation
 658    def implementation()
 659      ret = _getproperty(39, [], [])
 660      @lastargs = WIN32OLE::ARGV
 661      ret
 662    end
 663  
 664    # IXMLDOMElement documentElement
 665    # the root of the tree
 666    def documentElement()
 667      ret = _getproperty(40, [], [])
 668      @lastargs = WIN32OLE::ARGV
 669      ret
 670    end
 671  
 672    # I4 readyState
 673    # get the state of the XML document
 674    def readyState()
 675      ret = _getproperty(-525, [], [])
 676      @lastargs = WIN32OLE::ARGV
 677      ret
 678    end
 679  
 680    # IXMLDOMParseError parseError
 681    # get the last parser error
 682    def parseError()
 683      ret = _getproperty(59, [], [])
 684      @lastargs = WIN32OLE::ARGV
 685      ret
 686    end
 687  
 688    # BSTR url
 689    # get the URL for the loaded XML document
 690    def url()
 691      ret = _getproperty(60, [], [])
 692      @lastargs = WIN32OLE::ARGV
 693      ret
 694    end
 695  
 696    # BOOL async
 697    # flag for asynchronous download
 698    def async()
 699      ret = _getproperty(61, [], [])
 700      @lastargs = WIN32OLE::ARGV
 701      ret
 702    end
 703  
 704    # BOOL validateOnParse
 705    # indicates whether the parser performs validation
 706    def validateOnParse()
 707      ret = _getproperty(65, [], [])
 708      @lastargs = WIN32OLE::ARGV
 709      ret
 710    end
 711  
 712    # BOOL resolveExternals
 713    # indicates whether the parser resolves references to external DTD/Entities/Schema
 714    def resolveExternals()
 715      ret = _getproperty(66, [], [])
 716      @lastargs = WIN32OLE::ARGV
 717      ret
 718    end
 719  
 720    # BOOL preserveWhiteSpace
 721    # indicates whether the parser preserves whitespace
 722    def preserveWhiteSpace()
 723      ret = _getproperty(67, [], [])
 724      @lastargs = WIN32OLE::ARGV
 725      ret
 726    end
 727  
 728    # VOID nodeValue
 729    # value stored in the node
 730    def nodeValue=(arg0)
 731      ret = _setproperty(3, [arg0], [VT_VARIANT])
 732      @lastargs = WIN32OLE::ARGV
 733      ret
 734    end
 735  
 736    # VOID text
 737    # text content of the node and subtree
 738    def text=(arg0)
 739      ret = _setproperty(24, [arg0], [VT_BSTR])
 740      @lastargs = WIN32OLE::ARGV
 741      ret
 742    end
 743  
 744    # VOID nodeTypedValue
 745    # get the strongly typed value of the node
 746    def nodeTypedValue=(arg0)
 747      ret = _setproperty(25, [arg0], [VT_VARIANT])
 748      @lastargs = WIN32OLE::ARGV
 749      ret
 750    end
 751  
 752    # VOID dataType
 753    # the data type of the node
 754    def dataType=(arg0)
 755      ret = _setproperty(26, [arg0], [VT_VARIANT])
 756      @lastargs = WIN32OLE::ARGV
 757      ret
 758    end
 759  
 760    # VOID async
 761    # flag for asynchronous download
 762    def async=(arg0)
 763      ret = _setproperty(61, [arg0], [VT_BOOL])
 764      @lastargs = WIN32OLE::ARGV
 765      ret
 766    end
 767  
 768    # VOID validateOnParse
 769    # indicates whether the parser performs validation
 770    def validateOnParse=(arg0)
 771      ret = _setproperty(65, [arg0], [VT_BOOL])
 772      @lastargs = WIN32OLE::ARGV
 773      ret
 774    end
 775  
 776    # VOID resolveExternals
 777    # indicates whether the parser resolves references to external DTD/Entities/Schema
 778    def resolveExternals=(arg0)
 779      ret = _setproperty(66, [arg0], [VT_BOOL])
 780      @lastargs = WIN32OLE::ARGV
 781      ret
 782    end
 783  
 784    # VOID preserveWhiteSpace
 785    # indicates whether the parser preserves whitespace
 786    def preserveWhiteSpace=(arg0)
 787      ret = _setproperty(67, [arg0], [VT_BOOL])
 788      @lastargs = WIN32OLE::ARGV
 789      ret
 790    end
 791  
 792    # VOID onreadystatechange
 793    # register a readystatechange event handler
 794    def onreadystatechange=(arg0)
 795      ret = _setproperty(68, [arg0], [VT_VARIANT])
 796      @lastargs = WIN32OLE::ARGV
 797      ret
 798    end
 799  
 800    # VOID ondataavailable
 801    # register an ondataavailable event handler
 802    def ondataavailable=(arg0)
 803      ret = _setproperty(69, [arg0], [VT_VARIANT])
 804      @lastargs = WIN32OLE::ARGV
 805      ret
 806    end
 807  
 808    # VOID ontransformnode
 809    # register an ontransformnode event handler
 810    def ontransformnode=(arg0)
 811      ret = _setproperty(70, [arg0], [VT_VARIANT])
 812      @lastargs = WIN32OLE::ARGV
 813      ret
 814    end
 815  
 816    # IXMLDOMNode insertBefore
 817    # insert a child node
 818    #   IXMLDOMNode arg0 --- newChild [IN]
 819    #   VARIANT arg1 --- refChild [IN]
 820    def insertBefore(arg0, arg1)
 821      ret = _invoke(13, [arg0, arg1], [VT_BYREF|VT_DISPATCH, VT_VARIANT])
 822      @lastargs = WIN32OLE::ARGV
 823      ret
 824    end
 825  
 826    # IXMLDOMNode replaceChild
 827    # replace a child node
 828    #   IXMLDOMNode arg0 --- newChild [IN]
 829    #   IXMLDOMNode arg1 --- oldChild [IN]
 830    def replaceChild(arg0, arg1)
 831      ret = _invoke(14, [arg0, arg1], [VT_BYREF|VT_DISPATCH, VT_BYREF|VT_DISPATCH])
 832      @lastargs = WIN32OLE::ARGV
 833      ret
 834    end
 835  
 836    # IXMLDOMNode removeChild
 837    # remove a child node
 838    #   IXMLDOMNode arg0 --- childNode [IN]
 839    def removeChild(arg0)
 840      ret = _invoke(15, [arg0], [VT_BYREF|VT_DISPATCH])
 841      @lastargs = WIN32OLE::ARGV
 842      ret
 843    end
 844  
 845    # IXMLDOMNode appendChild
 846    # append a child node
 847    #   IXMLDOMNode arg0 --- newChild [IN]
 848    def appendChild(arg0)
 849      ret = _invoke(16, [arg0], [VT_BYREF|VT_DISPATCH])
 850      @lastargs = WIN32OLE::ARGV
 851      ret
 852    end
 853  
 854    # BOOL hasChildNodes
 855    def hasChildNodes()
 856      ret = _invoke(17, [], [])
 857      @lastargs = WIN32OLE::ARGV
 858      ret
 859    end
 860  
 861    # IXMLDOMNode cloneNode
 862    #   BOOL arg0 --- deep [IN]
 863    def cloneNode(arg0)
 864      ret = _invoke(19, [arg0], [VT_BOOL])
 865      @lastargs = WIN32OLE::ARGV
 866      ret
 867    end
 868  
 869    # BSTR transformNode
 870    # apply the stylesheet to the subtree
 871    #   IXMLDOMNode arg0 --- stylesheet [IN]
 872    def transformNode(arg0)
 873      ret = _invoke(28, [arg0], [VT_BYREF|VT_DISPATCH])
 874      @lastargs = WIN32OLE::ARGV
 875      ret
 876    end
 877  
 878    # IXMLDOMNodeList selectNodes
 879    # execute query on the subtree
 880    #   BSTR arg0 --- queryString [IN]
 881    def selectNodes(arg0)
 882      ret = _invoke(29, [arg0], [VT_BSTR])
 883      @lastargs = WIN32OLE::ARGV
 884      ret
 885    end
 886  
 887    # IXMLDOMNode selectSingleNode
 888    # execute query on the subtree
 889    #   BSTR arg0 --- queryString [IN]
 890    def selectSingleNode(arg0)
 891      ret = _invoke(30, [arg0], [VT_BSTR])
 892      @lastargs = WIN32OLE::ARGV
 893      ret
 894    end
 895  
 896    # VOID transformNodeToObject
 897    # apply the stylesheet to the subtree, returning the result through a document or a stream
 898    #   IXMLDOMNode arg0 --- stylesheet [IN]
 899    #   VARIANT arg1 --- outputObject [IN]
 900    def transformNodeToObject(arg0, arg1)
 901      ret = _invoke(35, [arg0, arg1], [VT_BYREF|VT_DISPATCH, VT_VARIANT])
 902      @lastargs = WIN32OLE::ARGV
 903      ret
 904    end
 905  
 906    # IXMLDOMElement createElement
 907    # create an Element node
 908    #   BSTR arg0 --- tagName [IN]
 909    def createElement(arg0)
 910      ret = _invoke(41, [arg0], [VT_BSTR])
 911      @lastargs = WIN32OLE::ARGV
 912      ret
 913    end
 914  
 915    # IXMLDOMDocumentFragment createDocumentFragment
 916    # create a DocumentFragment node
 917    def createDocumentFragment()
 918      ret = _invoke(42, [], [])
 919      @lastargs = WIN32OLE::ARGV
 920      ret
 921    end
 922  
 923    # IXMLDOMText createTextNode
 924    # create a text node
 925    #   BSTR arg0 --- data [IN]
 926    def createTextNode(arg0)
 927      ret = _invoke(43, [arg0], [VT_BSTR])
 928      @lastargs = WIN32OLE::ARGV
 929      ret
 930    end
 931  
 932    # IXMLDOMComment createComment
 933    # create a comment node
 934    #   BSTR arg0 --- data [IN]
 935    def createComment(arg0)
 936      ret = _invoke(44, [arg0], [VT_BSTR])
 937      @lastargs = WIN32OLE::ARGV
 938      ret
 939    end
 940  
 941    # IXMLDOMCDATASection createCDATASection
 942    # create a CDATA section node
 943    #   BSTR arg0 --- data [IN]
 944    def createCDATASection(arg0)
 945      ret = _invoke(45, [arg0], [VT_BSTR])
 946      @lastargs = WIN32OLE::ARGV
 947      ret
 948    end
 949  
 950    # IXMLDOMProcessingInstruction createProcessingInstruction
 951    # create a processing instruction node
 952    #   BSTR arg0 --- target [IN]
 953    #   BSTR arg1 --- data [IN]
 954    def createProcessingInstruction(arg0, arg1)
 955      ret = _invoke(46, [arg0, arg1], [VT_BSTR, VT_BSTR])
 956      @lastargs = WIN32OLE::ARGV
 957      ret
 958    end
 959  
 960    # IXMLDOMAttribute createAttribute
 961    # create an attribute node
 962    #   BSTR arg0 --- name [IN]
 963    def createAttribute(arg0)
 964      ret = _invoke(47, [arg0], [VT_BSTR])
 965      @lastargs = WIN32OLE::ARGV
 966      ret
 967    end
 968  
 969    # IXMLDOMEntityReference createEntityReference
 970    # create an entity reference node
 971    #   BSTR arg0 --- name [IN]
 972    def createEntityReference(arg0)
 973      ret = _invoke(49, [arg0], [VT_BSTR])
 974      @lastargs = WIN32OLE::ARGV
 975      ret
 976    end
 977  
 978    # IXMLDOMNodeList getElementsByTagName
 979    # build a list of elements by name
 980    #   BSTR arg0 --- tagName [IN]
 981    def getElementsByTagName(arg0)
 982      ret = _invoke(50, [arg0], [VT_BSTR])
 983      @lastargs = WIN32OLE::ARGV
 984      ret
 985    end
 986  
 987    # IXMLDOMNode createNode
 988    # create a node of the specified node type and name
 989    #   VARIANT arg0 --- type [IN]
 990    #   BSTR arg1 --- name [IN]
 991    #   BSTR arg2 --- namespaceURI [IN]
 992    def createNode(arg0, arg1, arg2)
 993      ret = _invoke(54, [arg0, arg1, arg2], [VT_VARIANT, VT_BSTR, VT_BSTR])
 994      @lastargs = WIN32OLE::ARGV
 995      ret
 996    end
 997  
 998    # IXMLDOMNode nodeFromID
 999    # retrieve node from it's ID
1000    #   BSTR arg0 --- idString [IN]
1001    def nodeFromID(arg0)
1002      ret = _invoke(56, [arg0], [VT_BSTR])
1003      @lastargs = WIN32OLE::ARGV
1004      ret
1005    end
1006  
1007    # BOOL load
1008    # load document from the specified XML source
1009    #   VARIANT arg0 --- xmlSource [IN]
1010    def load(arg0)
1011      ret = _invoke(58, [arg0], [VT_VARIANT])
1012      @lastargs = WIN32OLE::ARGV
1013      ret
1014    end
1015  
1016    # VOID abort
1017    # abort an asynchronous download
1018    def abort()
1019      ret = _invoke(62, [], [])
1020      @lastargs = WIN32OLE::ARGV
1021      ret
1022    end
1023  
1024    # BOOL loadXML
1025    # load the document from a string
1026    #   BSTR arg0 --- bstrXML [IN]
1027    def loadXML(arg0)
1028      ret = _invoke(63, [arg0], [VT_BSTR])
1029      @lastargs = WIN32OLE::ARGV
1030      ret
1031    end
1032  
1033    # VOID save
1034    # save the document to a specified desination
1035    #   VARIANT arg0 --- desination [IN]
1036    def save(arg0)
1037      ret = _invoke(64, [arg0], [VT_VARIANT])
1038      @lastargs = WIN32OLE::ARGV
1039      ret
1040    end
1041  end
1042  
1043  # 
1044  module IXMLDOMDocumentType
1045    include WIN32OLE::VARIANT
1046    attr_reader :lastargs
1047  
1048    # BSTR nodeName
1049    # name of the node
1050    def nodeName()
1051      ret = _getproperty(2, [], [])
1052      @lastargs = WIN32OLE::ARGV
1053      ret
1054    end
1055  
1056    # VARIANT nodeValue
1057    # value stored in the node
1058    def nodeValue()
1059      ret = _getproperty(3, [], [])
1060      @lastargs = WIN32OLE::ARGV
1061      ret
1062    end
1063  
1064    # DOMNodeType nodeType
1065    # the node's type
1066    def nodeType()
1067      ret = _getproperty(4, [], [])
1068      @lastargs = WIN32OLE::ARGV
1069      ret
1070    end
1071  
1072    # IXMLDOMNode parentNode
1073    # parent of the node
1074    def parentNode()
1075      ret = _getproperty(6, [], [])
1076      @lastargs = WIN32OLE::ARGV
1077      ret
1078    end
1079  
1080    # IXMLDOMNodeList childNodes
1081    # the collection of the node's children
1082    def childNodes()
1083      ret = _getproperty(7, [], [])
1084      @lastargs = WIN32OLE::ARGV
1085      ret
1086    end
1087  
1088    # IXMLDOMNode firstChild
1089    # first child of the node
1090    def firstChild()
1091      ret = _getproperty(8, [], [])
1092      @lastargs = WIN32OLE::ARGV
1093      ret
1094    end
1095  
1096    # IXMLDOMNode lastChild
1097    # first child of the node
1098    def lastChild()
1099      ret = _getproperty(9, [], [])
1100      @lastargs = WIN32OLE::ARGV
1101      ret
1102    end
1103  
1104    # IXMLDOMNode previousSibling
1105    # left sibling of the node
1106    def previousSibling()
1107      ret = _getproperty(10, [], [])
1108      @lastargs = WIN32OLE::ARGV
1109      ret
1110    end
1111  
1112    # IXMLDOMNode nextSibling
1113    # right sibling of the node
1114    def nextSibling()
1115      ret = _getproperty(11, [], [])
1116      @lastargs = WIN32OLE::ARGV
1117      ret
1118    end
1119  
1120    # IXMLDOMNamedNodeMap attributes
1121    # the collection of the node's attributes
1122    def attributes()
1123      ret = _getproperty(12, [], [])
1124      @lastargs = WIN32OLE::ARGV
1125      ret
1126    end
1127  
1128    # IXMLDOMDocument ownerDocument
1129    # document that contains the node
1130    def ownerDocument()
1131      ret = _getproperty(18, [], [])
1132      @lastargs = WIN32OLE::ARGV
1133      ret
1134    end
1135  
1136    # BSTR nodeTypeString
1137    # the type of node in string form
1138    def nodeTypeString()
1139      ret = _getproperty(21, [], [])
1140      @lastargs = WIN32OLE::ARGV
1141      ret
1142    end
1143  
1144    # BSTR text
1145    # text content of the node and subtree
1146    def text()
1147      ret = _getproperty(24, [], [])
1148      @lastargs = WIN32OLE::ARGV
1149      ret
1150    end
1151  
1152    # BOOL specified
1153    # indicates whether node is a default value
1154    def specified()
1155      ret = _getproperty(22, [], [])
1156      @lastargs = WIN32OLE::ARGV
1157      ret
1158    end
1159  
1160    # IXMLDOMNode definition
1161    # pointer to the definition of the node in the DTD or schema
1162    def definition()
1163      ret = _getproperty(23, [], [])
1164      @lastargs = WIN32OLE::ARGV
1165      ret
1166    end
1167  
1168    # VARIANT nodeTypedValue
1169    # get the strongly typed value of the node
1170    def nodeTypedValue()
1171      ret = _getproperty(25, [], [])
1172      @lastargs = WIN32OLE::ARGV
1173      ret
1174    end
1175  
1176    # VARIANT dataType
1177    # the data type of the node
1178    def dataType()
1179      ret = _getproperty(26, [], [])
1180      @lastargs = WIN32OLE::ARGV
1181      ret
1182    end
1183  
1184    # BSTR xml
1185    # return the XML source for the node and each of its descendants
1186    def xml()
1187      ret = _getproperty(27, [], [])
1188      @lastargs = WIN32OLE::ARGV
1189      ret
1190    end
1191  
1192    # BOOL parsed
1193    # has sub-tree been completely parsed
1194    def parsed()
1195      ret = _getproperty(31, [], [])
1196      @lastargs = WIN32OLE::ARGV
1197      ret
1198    end
1199  
1200    # BSTR namespaceURI
1201    # the URI for the namespace applying to the node
1202    def namespaceURI()
1203      ret = _getproperty(32, [], [])
1204      @lastargs = WIN32OLE::ARGV
1205      ret
1206    end
1207  
1208    # BSTR prefix
1209    # the prefix for the namespace applying to the node
1210    def prefix()
1211      ret = _getproperty(33, [], [])
1212      @lastargs = WIN32OLE::ARGV
1213      ret
1214    end
1215  
1216    # BSTR baseName
1217    # the base name of the node (nodename with the prefix stripped off)
1218    def baseName()
1219      ret = _getproperty(34, [], [])
1220      @lastargs = WIN32OLE::ARGV
1221      ret
1222    end
1223  
1224    # BSTR name
1225    # name of the document type (root of the tree)
1226    def name()
1227      ret = _getproperty(131, [], [])
1228      @lastargs = WIN32OLE::ARGV
1229      ret
1230    end
1231  
1232    # IXMLDOMNamedNodeMap entities
1233    # a list of entities in the document
1234    def entities()
1235      ret = _getproperty(132, [], [])
1236      @lastargs = WIN32OLE::ARGV
1237      ret
1238    end
1239  
1240    # IXMLDOMNamedNodeMap notations
1241    # a list of notations in the document
1242    def notations()
1243      ret = _getproperty(133, [], [])
1244      @lastargs = WIN32OLE::ARGV
1245      ret
1246    end
1247  
1248    # VOID nodeValue
1249    # value stored in the node
1250    def nodeValue=(arg0)
1251      ret = _setproperty(3, [arg0], [VT_VARIANT])
1252      @lastargs = WIN32OLE::ARGV
1253      ret
1254    end
1255  
1256    # VOID text
1257    # text content of the node and subtree
1258    def text=(arg0)
1259      ret = _setproperty(24, [arg0], [VT_BSTR])
1260      @lastargs = WIN32OLE::ARGV
1261      ret
1262    end
1263  
1264    # VOID nodeTypedValue
1265    # get the strongly typed value of the node
1266    def nodeTypedValue=(arg0)
1267      ret = _setproperty(25, [arg0], [VT_VARIANT])
1268      @lastargs = WIN32OLE::ARGV
1269      ret
1270    end
1271  
1272    # VOID dataType
1273    # the data type of the node
1274    def dataType=(arg0)
1275      ret = _setproperty(26, [arg0], [VT_VARIANT])
1276      @lastargs = WIN32OLE::ARGV
1277      ret
1278    end
1279  
1280    # IXMLDOMNode insertBefore
1281    # insert a child node
1282    #   IXMLDOMNode arg0 --- newChild [IN]
1283    #   VARIANT arg1 --- refChild [IN]
1284    def insertBefore(arg0, arg1)
1285      ret = _invoke(13, [arg0, arg1], [VT_BYREF|VT_DISPATCH, VT_VARIANT])
1286      @lastargs = WIN32OLE::ARGV
1287      ret
1288    end
1289  
1290    # IXMLDOMNode replaceChild
1291    # replace a child node
1292    #   IXMLDOMNode arg0 --- newChild [IN]
1293    #   IXMLDOMNode arg1 --- oldChild [IN]
1294    def replaceChild(arg0, arg1)
1295      ret = _invoke(14, [arg0, arg1], [VT_BYREF|VT_DISPATCH, VT_BYREF|VT_DISPATCH])
1296      @lastargs = WIN32OLE::ARGV
1297      ret
1298    end
1299  
1300    # IXMLDOMNode removeChild
1301    # remove a child node
1302    #   IXMLDOMNode arg0 --- childNode [IN]
1303    def removeChild(arg0)
1304      ret = _invoke(15, [arg0], [VT_BYREF|VT_DISPATCH])
1305      @lastargs = WIN32OLE::ARGV
1306      ret
1307    end
1308  
1309    # IXMLDOMNode appendChild
1310    # append a child node
1311    #   IXMLDOMNode arg0 --- newChild [IN]
1312    def appendChild(arg0)
1313      ret = _invoke(16, [arg0], [VT_BYREF|VT_DISPATCH])
1314      @lastargs = WIN32OLE::ARGV
1315      ret
1316    end
1317  
1318    # BOOL hasChildNodes
1319    def hasChildNodes()
1320      ret = _invoke(17, [], [])
1321      @lastargs = WIN32OLE::ARGV
1322      ret
1323    end
1324  
1325    # IXMLDOMNode cloneNode
1326    #   BOOL arg0 --- deep [IN]
1327    def cloneNode(arg0)
1328      ret = _invoke(19, [arg0], [VT_BOOL])
1329      @lastargs = WIN32OLE::ARGV
1330      ret
1331    end
1332  
1333    # BSTR transformNode
1334    # apply the stylesheet to the subtree
1335    #   IXMLDOMNode arg0 --- stylesheet [IN]
1336    def transformNode(arg0)
1337      ret = _invoke(28, [arg0], [VT_BYREF|VT_DISPATCH])
1338      @lastargs = WIN32OLE::ARGV
1339      ret
1340    end
1341  
1342    # IXMLDOMNodeList selectNodes
1343    # execute query on the subtree
1344    #   BSTR arg0 --- queryString [IN]
1345    def selectNodes(arg0)
1346      ret = _invoke(29, [arg0], [VT_BSTR])
1347      @lastargs = WIN32OLE::ARGV
1348      ret
1349    end
1350  
1351    # IXMLDOMNode selectSingleNode
1352    # execute query on the subtree
1353    #   BSTR arg0 --- queryString [IN]
1354    def selectSingleNode(arg0)
1355      ret = _invoke(30, [arg0], [VT_BSTR])
1356      @lastargs = WIN32OLE::ARGV
1357      ret
1358    end
1359  
1360    # VOID transformNodeToObject
1361    # apply the stylesheet to the subtree, returning the result through a document or a stream
1362    #   IXMLDOMNode arg0 --- stylesheet [IN]
1363    #   VARIANT arg1 --- outputObject [IN]
1364    def transformNodeToObject(arg0, arg1)
1365      ret = _invoke(35, [arg0, arg1], [VT_BYREF|VT_DISPATCH, VT_VARIANT])
1366      @lastargs = WIN32OLE::ARGV
1367      ret
1368    end
1369  end
1370  
1371  # 
1372  module IXMLDOMElement
1373    include WIN32OLE::VARIANT
1374    attr_reader :lastargs
1375  
1376    # BSTR nodeName
1377    # name of the node
1378    def nodeName()
1379      ret = _getproperty(2, [], [])
1380      @lastargs = WIN32OLE::ARGV
1381      ret
1382    end
1383  
1384    # VARIANT nodeValue
1385    # value stored in the node
1386    def nodeValue()
1387      ret = _getproperty(3, [], [])
1388      @lastargs = WIN32OLE::ARGV
1389      ret
1390    end
1391  
1392    # DOMNodeType nodeType
1393    # the node's type
1394    def nodeType()
1395      ret = _getproperty(4, [], [])
1396      @lastargs = WIN32OLE::ARGV
1397      ret
1398    end
1399  
1400    # IXMLDOMNode parentNode
1401    # parent of the node
1402    def parentNode()
1403      ret = _getproperty(6, [], [])
1404      @lastargs = WIN32OLE::ARGV
1405      ret
1406    end
1407  
1408    # IXMLDOMNodeList childNodes
1409    # the collection of the node's children
1410    def childNodes()
1411      ret = _getproperty(7, [], [])
1412      @lastargs = WIN32OLE::ARGV
1413      ret
1414    end
1415  
1416    # IXMLDOMNode firstChild
1417    # first child of the node
1418    def firstChild()
1419      ret = _getproperty(8, [], [])
1420      @lastargs = WIN32OLE::ARGV
1421      ret
1422    end
1423  
1424    # IXMLDOMNode lastChild
1425    # first child of the node
1426    def lastChild()
1427      ret = _getproperty(9, [], [])
1428      @lastargs = WIN32OLE::ARGV
1429      ret
1430    end
1431  
1432    # IXMLDOMNode previousSibling
1433    # left sibling of the node
1434    def previousSibling()
1435      ret = _getproperty(10, [], [])
1436      @lastargs = WIN32OLE::ARGV
1437      ret
1438    end
1439  
1440    # IXMLDOMNode nextSibling
1441    # right sibling of the node
1442    def nextSibling()
1443      ret = _getproperty(11, [], [])
1444      @lastargs = WIN32OLE::ARGV
1445      ret
1446    end
1447  
1448    # IXMLDOMNamedNodeMap attributes
1449    # the collection of the node's attributes
1450    def attributes()
1451      ret = _getproperty(12, [], [])
1452      @lastargs = WIN32OLE::ARGV
1453      ret
1454    end
1455  
1456    # IXMLDOMDocument ownerDocument
1457    # document that contains the node
1458    def ownerDocument()
1459      ret = _getproperty(18, [], [])
1460      @lastargs = WIN32OLE::ARGV
1461      ret
1462    end
1463  
1464    # BSTR nodeTypeString
1465    # the type of node in string form
1466    def nodeTypeString()
1467      ret = _getproperty(21, [], [])
1468      @lastargs = WIN32OLE::ARGV
1469      ret
1470    end
1471  
1472    # BSTR text
1473    # text content of the node and subtree
1474    def text()
1475      ret = _getproperty(24, [], [])
1476      @lastargs = WIN32OLE::ARGV
1477      ret
1478    end
1479  
1480    # BOOL specified
1481    # indicates whether node is a default value
1482    def specified()
1483      ret = _getproperty(22, [], [])
1484      @lastargs = WIN32OLE::ARGV
1485      ret
1486    end
1487  
1488    # IXMLDOMNode definition
1489    # pointer to the definition of the node in the DTD or schema
1490    def definition()
1491      ret = _getproperty(23, [], [])
1492      @lastargs = WIN32OLE::ARGV
1493      ret
1494    end
1495  
1496    # VARIANT nodeTypedValue
1497    # get the strongly typed value of the node
1498    def nodeTypedValue()
1499      ret = _getproperty(25, [], [])
1500      @lastargs = WIN32OLE::ARGV
1501      ret
1502    end
1503  
1504    # VARIANT dataType
1505    # the data type of the node
1506    def dataType()
1507      ret = _getproperty(26, [], [])
1508      @lastargs = WIN32OLE::ARGV
1509      ret
1510    end
1511  
1512    # BSTR xml
1513    # return the XML source for the node and each of its descendants
1514    def xml()
1515      ret = _getproperty(27, [], [])
1516      @lastargs = WIN32OLE::ARGV
1517      ret
1518    end
1519  
1520    # BOOL parsed
1521    # has sub-tree been completely parsed
1522    def parsed()
1523      ret = _getproperty(31, [], [])
1524      @lastargs = WIN32OLE::ARGV
1525      ret
1526    end
1527  
1528    # BSTR namespaceURI
1529    # the URI for the namespace applying to the node
1530    def namespaceURI()
1531      ret = _getproperty(32, [], [])
1532      @lastargs = WIN32OLE::ARGV
1533      ret
1534    end
1535  
1536    # BSTR prefix
1537    # the prefix for the namespace applying to the node
1538    def prefix()
1539      ret = _getproperty(33, [], [])
1540      @lastargs = WIN32OLE::ARGV
1541      ret
1542    end
1543  
1544    # BSTR baseName
1545    # the base name of the node (nodename with the prefix stripped off)
1546    def baseName()
1547      ret = _getproperty(34, [], [])
1548      @lastargs = WIN32OLE::ARGV
1549      ret
1550    end
1551  
1552    # BSTR tagName
1553    # get the tagName of the element
1554    def tagName()
1555      ret = _getproperty(97, [], [])
1556      @lastargs = WIN32OLE::ARGV
1557      ret
1558    end
1559  
1560    # VOID nodeValue
1561    # value stored in the node
1562    def nodeValue=(arg0)
1563      ret = _setproperty(3, [arg0], [VT_VARIANT])
1564      @lastargs = WIN32OLE::ARGV
1565      ret
1566    end
1567  
1568    # VOID text
1569    # text content of the node and subtree
1570    def text=(arg0)
1571      ret = _setproperty(24, [arg0], [VT_BSTR])
1572      @lastargs = WIN32OLE::ARGV
1573      ret
1574    end
1575  
1576    # VOID nodeTypedValue
1577    # get the strongly typed value of the node
1578    def nodeTypedValue=(arg0)
1579      ret = _setproperty(25, [arg0], [VT_VARIANT])
1580      @lastargs = WIN32OLE::ARGV
1581      ret
1582    end
1583  
1584    # VOID dataType
1585    # the data type of the node
1586    def dataType=(arg0)
1587      ret = _setproperty(26, [arg0], [VT_VARIANT])
1588      @lastargs = WIN32OLE::ARGV
1589      ret
1590    end
1591  
1592    # IXMLDOMNode insertBefore
1593    # insert a child node
1594    #   IXMLDOMNode arg0 --- newChild [IN]
1595    #   VARIANT arg1 --- refChild [IN]
1596    def insertBefore(arg0, arg1)
1597      ret = _invoke(13, [arg0, arg1], [VT_BYREF|VT_DISPATCH, VT_VARIANT])
1598      @lastargs = WIN32OLE::ARGV
1599      ret
1600    end
1601  
1602    # IXMLDOMNode replaceChild
1603    # replace a child node
1604    #   IXMLDOMNode arg0 --- newChild [IN]
1605    #   IXMLDOMNode arg1 --- oldChild [IN]
1606    def replaceChild(arg0, arg1)
1607      ret = _invoke(14, [arg0, arg1], [VT_BYREF|VT_DISPATCH, VT_BYREF|VT_DISPATCH])
1608      @lastargs = WIN32OLE::ARGV
1609      ret
1610    end
1611  
1612    # IXMLDOMNode removeChild
1613    # remove a child node
1614    #   IXMLDOMNode arg0 --- childNode [IN]
1615    def removeChild(arg0)
1616      ret = _invoke(15, [arg0], [VT_BYREF|VT_DISPATCH])
1617      @lastargs = WIN32OLE::ARGV
1618      ret
1619    end
1620  
1621    # IXMLDOMNode appendChild
1622    # append a child node
1623    #   IXMLDOMNode arg0 --- newChild [IN]
1624    def appendChild(arg0)
1625      ret = _invoke(16, [arg0], [VT_BYREF|VT_DISPATCH])
1626      @lastargs = WIN32OLE::ARGV
1627      ret
1628    end
1629  
1630    # BOOL hasChildNodes
1631    def hasChildNodes()
1632      ret = _invoke(17, [], [])
1633      @lastargs = WIN32OLE::ARGV
1634      ret
1635    end
1636  
1637    # IXMLDOMNode cloneNode
1638    #   BOOL arg0 --- deep [IN]
1639    def cloneNode(arg0)
1640      ret = _invoke(19, [arg0], [VT_BOOL])
1641      @lastargs = WIN32OLE::ARGV
1642      ret
1643    end
1644  
1645    # BSTR transformNode
1646    # apply the stylesheet to the subtree
1647    #   IXMLDOMNode arg0 --- stylesheet [IN]
1648    def transformNode(arg0)
1649      ret = _invoke(28, [arg0], [VT_BYREF|VT_DISPATCH])
1650      @lastargs = WIN32OLE::ARGV
1651      ret
1652    end
1653  
1654    # IXMLDOMNodeList selectNodes
1655    # execute query on the subtree
1656    #   BSTR arg0 --- queryString [IN]
1657    def selectNodes(arg0)
1658      ret = _invoke(29, [arg0], [VT_BSTR])
1659      @lastargs = WIN32OLE::ARGV
1660      ret
1661    end
1662  
1663    # IXMLDOMNode selectSingleNode
1664    # execute query on the subtree
1665    #   BSTR arg0 --- queryString [IN]
1666    def selectSingleNode(arg0)
1667      ret = _invoke(30, [arg0], [VT_BSTR])
1668      @lastargs = WIN32OLE::ARGV
1669      ret
1670    end
1671  
1672    # VOID transformNodeToObject
1673    # apply the stylesheet to the subtree, returning the result through a document or a stream
1674    #   IXMLDOMNode arg0 --- stylesheet [IN]
1675    #   VARIANT arg1 --- outputObject [IN]
1676    def transformNodeToObject(arg0, arg1)
1677      ret = _invoke(35, [arg0, arg1], [VT_BYREF|VT_DISPATCH, VT_VARIANT])
1678      @lastargs = WIN32OLE::ARGV
1679      ret
1680    end
1681  
1682    # VARIANT getAttribute
1683    # look up the string value of an attribute by name
1684    #   BSTR arg0 --- name [IN]
1685    def getAttribute(arg0)
1686      ret = _invoke(99, [arg0], [VT_BSTR])
1687      @lastargs = WIN32OLE::ARGV
1688      ret
1689    end
1690  
1691    # VOID setAttribute
1692    # set the string value of an attribute by name
1693    #   BSTR arg0 --- name [IN]
1694    #   VARIANT arg1 --- value [IN]
1695    def setAttribute(arg0, arg1)
1696      ret = _invoke(100, [arg0, arg1], [VT_BSTR, VT_VARIANT])
1697      @lastargs = WIN32OLE::ARGV
1698      ret
1699    end
1700  
1701    # VOID removeAttribute
1702    # remove an attribute by name
1703    #   BSTR arg0 --- name [IN]
1704    def removeAttribute(arg0)
1705      ret = _invoke(101, [arg0], [VT_BSTR])
1706      @lastargs = WIN32OLE::ARGV
1707      ret
1708    end
1709  
1710    # IXMLDOMAttribute getAttributeNode
1711    # look up the attribute node by name
1712    #   BSTR arg0 --- name [IN]
1713    def getAttributeNode(arg0)
1714      ret = _invoke(102, [arg0], [VT_BSTR])
1715      @lastargs = WIN32OLE::ARGV
1716      ret
1717    end
1718  
1719    # IXMLDOMAttribute setAttributeNode
1720    # set the specified attribute on the element
1721    #   IXMLDOMAttribute arg0 --- DOMAttribute [IN]
1722    def setAttributeNode(arg0)
1723      ret = _invoke(103, [arg0], [VT_BYREF|VT_DISPATCH])
1724      @lastargs = WIN32OLE::ARGV
1725      ret
1726    end
1727  
1728    # IXMLDOMAttribute removeAttributeNode
1729    # remove the specified attribute
1730    #   IXMLDOMAttribute arg0 --- DOMAttribute [IN]
1731    def removeAttributeNode(arg0)
1732      ret = _invoke(104, [arg0], [VT_BYREF|VT_DISPATCH])
1733      @lastargs = WIN32OLE::ARGV
1734      ret
1735    end
1736  
1737    # IXMLDOMNodeList getElementsByTagName
1738    # build a list of elements by name
1739    #   BSTR arg0 --- tagName [IN]
1740    def getElementsByTagName(arg0)
1741      ret = _invoke(105, [arg0], [VT_BSTR])
1742      @lastargs = WIN32OLE::ARGV
1743      ret
1744    end
1745  
1746    # VOID normalize
1747    # collapse all adjacent text nodes in sub-tree
1748    def normalize()
1749      ret = _invoke(106, [], [])
1750      @lastargs = WIN32OLE::ARGV
1751      ret
1752    end
1753  end
1754  
1755  # 
1756  module IXMLDOMAttribute
1757    include WIN32OLE::VARIANT
1758    attr_reader :lastargs
1759  
1760    # BSTR nodeName
1761    # name of the node
1762    def nodeName()
1763      ret = _getproperty(2, [], [])
1764      @lastargs = WIN32OLE::ARGV
1765      ret
1766    end
1767  
1768    # VARIANT nodeValue
1769    # value stored in the node
1770    def nodeValue()
1771      ret = _getproperty(3, [], [])
1772      @lastargs = WIN32OLE::ARGV
1773      ret
1774    end
1775  
1776    # DOMNodeType nodeType
1777    # the node's type
1778    def nodeType()
1779      ret = _getproperty(4, [], [])
1780      @lastargs = WIN32OLE::ARGV
1781      ret
1782    end
1783  
1784    # IXMLDOMNode parentNode
1785    # parent of the node
1786    def parentNode()
1787      ret = _getproperty(6, [], [])
1788      @lastargs = WIN32OLE::ARGV
1789      ret
1790    end
1791  
1792    # IXMLDOMNodeList childNodes
1793    # the collection of the node's children
1794    def childNodes()
1795      ret = _getproperty(7, [], [])
1796      @lastargs = WIN32OLE::ARGV
1797      ret
1798    end
1799  
1800    # IXMLDOMNode firstChild
1801    # first child of the node
1802    def firstChild()
1803      ret = _getproperty(8, [], [])
1804      @lastargs = WIN32OLE::ARGV
1805      ret
1806    end
1807  
1808    # IXMLDOMNode lastChild
1809    # first child of the node
1810    def lastChild()
1811      ret = _getproperty(9, [], [])
1812      @lastargs = WIN32OLE::ARGV
1813      ret
1814    end
1815  
1816    # IXMLDOMNode previousSibling
1817    # left sibling of the node
1818    def previousSibling()
1819      ret = _getproperty(10, [], [])
1820      @lastargs = WIN32OLE::ARGV
1821      ret
1822    end
1823  
1824    # IXMLDOMNode nextSibling
1825    # right sibling of the node
1826    def nextSibling()
1827      ret = _getproperty(11, [], [])
1828      @lastargs = WIN32OLE::ARGV
1829      ret
1830    end
1831  
1832    # IXMLDOMNamedNodeMap attributes
1833    # the collection of the node's attributes
1834    def attributes()
1835      ret = _getproperty(12, [], [])
1836      @lastargs = WIN32OLE::ARGV
1837      ret
1838    end
1839  
1840    # IXMLDOMDocument ownerDocument
1841    # document that contains the node
1842    def ownerDocument()
1843      ret = _getproperty(18, [], [])
1844      @lastargs = WIN32OLE::ARGV
1845      ret
1846    end
1847  
1848    # BSTR nodeTypeString
1849    # the type of node in string form
1850    def nodeTypeString()
1851      ret = _getproperty(21, [], [])
1852      @lastargs = WIN32OLE::ARGV
1853      ret
1854    end
1855  
1856    # BSTR text
1857    # text content of the node and subtree
1858    def text()
1859      ret = _getproperty(24, [], [])
1860      @lastargs = WIN32OLE::ARGV
1861      ret
1862    end
1863  
1864    # BOOL specified
1865    # indicates whether node is a default value
1866    def specified()
1867      ret = _getproperty(22, [], [])
1868      @lastargs = WIN32OLE::ARGV
1869      ret
1870    end
1871  
1872    # IXMLDOMNode definition
1873    # pointer to the definition of the node in the DTD or schema
1874    def definition()
1875      ret = _getproperty(23, [], [])
1876      @lastargs = WIN32OLE::ARGV
1877      ret
1878    end
1879  
1880    # VARIANT nodeTypedValue
1881    # get the strongly typed value of the node
1882    def nodeTypedValue()
1883      ret = _getproperty(25, [], [])
1884      @lastargs = WIN32OLE::ARGV
1885      ret
1886    end
1887  
1888    # VARIANT dataType
1889    # the data type of the node
1890    def dataType()
1891      ret = _getproperty(26, [], [])
1892      @lastargs = WIN32OLE::ARGV
1893      ret
1894    end
1895  
1896    # BSTR xml
1897    # return the XML source for the node and each of its descendants
1898    def xml()
1899      ret = _getproperty(27, [], [])
1900      @lastargs = WIN32OLE::ARGV
1901      ret
1902    end
1903  
1904    # BOOL parsed
1905    # has sub-tree been completely parsed
1906    def parsed()
1907      ret = _getproperty(31, [], [])
1908      @lastargs = WIN32OLE::ARGV
1909      ret
1910    end
1911  
1912    # BSTR namespaceURI
1913    # the URI for the namespace applying to the node
1914    def namespaceURI()
1915      ret = _getproperty(32, [], [])
1916      @lastargs = WIN32OLE::ARGV
1917      ret
1918    end
1919  
1920    # BSTR prefix
1921    # the prefix for the namespace applying to the node
1922    def prefix()
1923      ret = _getproperty(33, [], [])
1924      @lastargs = WIN32OLE::ARGV
1925      ret
1926    end
1927  
1928    # BSTR baseName
1929    # the base name of the node (nodename with the prefix stripped off)
1930    def baseName()
1931      ret = _getproperty(34, [], [])
1932      @lastargs = WIN32OLE::ARGV
1933      ret
1934    end
1935  
1936    # BSTR name
1937    # get name of the attribute
1938    def name()
1939      ret = _getproperty(118, [], [])
1940      @lastargs = WIN32OLE::ARGV
1941      ret
1942    end
1943  
1944    # VARIANT value
1945    # string value of the attribute
1946    def value()
1947      ret = _getproperty(120, [], [])
1948      @lastargs = WIN32OLE::ARGV
1949      ret
1950    end
1951  
1952    # VOID nodeValue
1953    # value stored in the node
1954    def nodeValue=(arg0)
1955      ret = _setproperty(3, [arg0], [VT_VARIANT])
1956      @lastargs = WIN32OLE::ARGV
1957      ret
1958    end
1959  
1960    # VOID text
1961    # text content of the node and subtree
1962    def text=(arg0)
1963      ret = _setproperty(24, [arg0], [VT_BSTR])
1964      @lastargs = WIN32OLE::ARGV
1965      ret
1966    end
1967  
1968    # VOID nodeTypedValue
1969    # get the strongly typed value of the node
1970    def nodeTypedValue=(arg0)
1971      ret = _setproperty(25, [arg0], [VT_VARIANT])
1972      @lastargs = WIN32OLE::ARGV
1973      ret
1974    end
1975  
1976    # VOID dataType
1977    # the data type of the node
1978    def dataType=(arg0)
1979      ret = _setproperty(26, [arg0], [VT_VARIANT])
1980      @lastargs = WIN32OLE::ARGV
1981      ret
1982    end
1983  
1984    # VOID value
1985    # string value of the attribute
1986    def value=(arg0)
1987      ret = _setproperty(120, [arg0], [VT_VARIANT])
1988      @lastargs = WIN32OLE::ARGV
1989      ret
1990    end
1991  
1992    # IXMLDOMNode insertBefore
1993    # insert a child node
1994    #   IXMLDOMNode arg0 --- newChild [IN]
1995    #   VARIANT arg1 --- refChild [IN]
1996    def insertBefore(arg0, arg1)
1997      ret = _invoke(13, [arg0, arg1], [VT_BYREF|VT_DISPATCH, VT_VARIANT])
1998      @lastargs = WIN32OLE::ARGV
1999      ret
2000    end
2001  
2002    # IXMLDOMNode replaceChild
2003    # replace a child node
2004    #   IXMLDOMNode arg0 --- newChild [IN]
2005    #   IXMLDOMNode arg1 --- oldChild [IN]
2006    def replaceChild(arg0, arg1)
2007      ret = _invoke(14, [arg0, arg1], [VT_BYREF|VT_DISPATCH, VT_BYREF|VT_DISPATCH])
2008      @lastargs = WIN32OLE::ARGV
2009      ret
2010    end
2011  
2012    # IXMLDOMNode removeChild
2013    # remove a child node
2014    #   IXMLDOMNode arg0 --- childNode [IN]
2015    def removeChild(arg0)
2016      ret = _invoke(15, [arg0], [VT_BYREF|VT_DISPATCH])
2017      @lastargs = WIN32OLE::ARGV
2018      ret
2019    end
2020  
2021    # IXMLDOMNode appendChild
2022    # append a child node
2023    #   IXMLDOMNode arg0 --- newChild [IN]
2024    def appendChild(arg0)
2025      ret = _invoke(16, [arg0], [VT_BYREF|VT_DISPATCH])
2026      @lastargs = WIN32OLE::ARGV
2027      ret
2028    end
2029  
2030    # BOOL hasChildNodes
2031    def hasChildNodes()
2032      ret = _invoke(17, [], [])
2033      @lastargs = WIN32OLE::ARGV
2034      ret
2035    end
2036  
2037    # IXMLDOMNode cloneNode
2038    #   BOOL arg0 --- deep [IN]
2039    def cloneNode(arg0)
2040      ret = _invoke(19, [arg0], [VT_BOOL])
2041      @lastargs = WIN32OLE::ARGV
2042      ret
2043    end
2044  
2045    # BSTR transformNode
2046    # apply the stylesheet to the subtree
2047    #   IXMLDOMNode arg0 --- stylesheet [IN]
2048    def transformNode(arg0)
2049      ret = _invoke(28, [arg0], [VT_BYREF|VT_DISPATCH])
2050      @lastargs = WIN32OLE::ARGV
2051      ret
2052    end
2053  
2054    # IXMLDOMNodeList selectNodes
2055    # execute query on the subtree
2056    #   BSTR arg0 --- queryString [IN]
2057    def selectNodes(arg0)
2058      ret = _invoke(29, [arg0], [VT_BSTR])
2059      @lastargs = WIN32OLE::ARGV
2060      ret
2061    end
2062  
2063    # IXMLDOMNode selectSingleNode
2064    # execute query on the subtree
2065    #   BSTR arg0 --- queryString [IN]
2066    def selectSingleNode(arg0)
2067      ret = _invoke(30, [arg0], [VT_BSTR])
2068      @lastargs = WIN32OLE::ARGV
2069      ret
2070    end
2071  
2072    # VOID transformNodeToObject
2073    # apply the stylesheet to the subtree, returning the result through a document or a stream
2074    #   IXMLDOMNode arg0 --- stylesheet [IN]
2075    #   VARIANT arg1 --- outputObject [IN]
2076    def transformNodeToObject(arg0, arg1)
2077      ret = _invoke(35, [arg0, arg1], [VT_BYREF|VT_DISPATCH, VT_VARIANT])
2078      @lastargs = WIN32OLE::ARGV
2079      ret
2080    end
2081  end
2082  
2083  # 
2084  module IXMLDOMDocumentFragment
2085    include WIN32OLE::VARIANT
2086    attr_reader :lastargs
2087  
2088    # BSTR nodeName
2089    # name of the node
2090    def nodeName()
2091      ret = _getproperty(2, [], [])
2092      @lastargs = WIN32OLE::ARGV
2093      ret
2094    end
2095  
2096    # VARIANT nodeValue
2097    # value stored in the node
2098    def nodeValue()
2099      ret = _getproperty(3, [], [])
2100      @lastargs = WIN32OLE::ARGV
2101      ret
2102    end
2103  
2104    # DOMNodeType nodeType
2105    # the node's type
2106    def nodeType()
2107      ret = _getproperty(4, [], [])
2108      @lastargs = WIN32OLE::ARGV
2109      ret
2110    end
2111  
2112    # IXMLDOMNode parentNode
2113    # parent of the node
2114    def parentNode()
2115      ret = _getproperty(6, [], [])
2116      @lastargs = WIN32OLE::ARGV
2117      ret
2118    end
2119  
2120    # IXMLDOMNodeList childNodes
2121    # the collection of the node's children
2122    def childNodes()
2123      ret = _getproperty(7, [], [])
2124      @lastargs = WIN32OLE::ARGV
2125      ret
2126    end
2127  
2128    # IXMLDOMNode firstChild
2129    # first child of the node
2130    def firstChild()
2131      ret = _getproperty(8, [], [])
2132      @lastargs = WIN32OLE::ARGV
2133      ret
2134    end
2135  
2136    # IXMLDOMNode lastChild
2137    # first child of the node
2138    def lastChild()
2139      ret = _getproperty(9, [], [])
2140      @lastargs = WIN32OLE::ARGV
2141      ret
2142    end
2143  
2144    # IXMLDOMNode previousSibling
2145    # left sibling of the node
2146    def previousSibling()
2147      ret = _getproperty(10, [], [])
2148      @lastargs = WIN32OLE::ARGV
2149      ret
2150    end
2151  
2152    # IXMLDOMNode nextSibling
2153    # right sibling of the node
2154    def nextSibling()
2155      ret = _getproperty(11, [], [])
2156      @lastargs = WIN32OLE::ARGV
2157      ret
2158    end
2159  
2160    # IXMLDOMNamedNodeMap attributes
2161    # the collection of the node's attributes
2162    def attributes()
2163      ret = _getproperty(12, [], [])
2164      @lastargs = WIN32OLE::ARGV
2165      ret
2166    end
2167  
2168    # IXMLDOMDocument ownerDocument
2169    # document that contains the node
2170    def ownerDocument()
2171      ret = _getproperty(18, [], [])
2172      @lastargs = WIN32OLE::ARGV
2173      ret
2174    end
2175  
2176    # BSTR nodeTypeString
2177    # the type of node in string form
2178    def nodeTypeString()
2179      ret = _getproperty(21, [], [])
2180      @lastargs = WIN32OLE::ARGV
2181      ret
2182    end
2183  
2184    # BSTR text
2185    # text content of the node and subtree
2186    def text()
2187      ret = _getproperty(24, [], [])
2188      @lastargs = WIN32OLE::ARGV
2189      ret
2190    end
2191  
2192    # BOOL specified
2193    # indicates whether node is a default value
2194    def specified()
2195      ret = _getproperty(22, [], [])
2196      @lastargs = WIN32OLE::ARGV
2197      ret
2198    end
2199  
2200    # IXMLDOMNode definition
2201    # pointer to the definition of the node in the DTD or schema
2202    def definition()
2203      ret = _getproperty(23, [], [])
2204      @lastargs = WIN32OLE::ARGV
2205      ret
2206    end
2207  
2208    # VARIANT nodeTypedValue
2209    # get the strongly typed value of the node
2210    def nodeTypedValue()
2211      ret = _getproperty(25, [], [])
2212      @lastargs = WIN32OLE::ARGV
2213      ret
2214    end
2215  
2216    # VARIANT dataType
2217    # the data type of the node
2218    def dataType()
2219      ret = _getproperty(26, [], [])
2220      @lastargs = WIN32OLE::ARGV
2221      ret
2222    end
2223  
2224    # BSTR xml
2225    # return the XML source for the node and each of its descendants
2226    def xml()
2227      ret = _getproperty(27, [], [])
2228      @lastargs = WIN32OLE::ARGV
2229      ret
2230    end
2231  
2232    # BOOL parsed
2233    # has sub-tree been completely parsed
2234    def parsed()
2235      ret = _getproperty(31, [], [])
2236      @lastargs = WIN32OLE::ARGV
2237      ret
2238    end
2239  
2240    # BSTR namespaceURI
2241    # the URI for the namespace applying to the node
2242    def namespaceURI()
2243      ret = _getproperty(32, [], [])
2244      @lastargs = WIN32OLE::ARGV
2245      ret
2246    end
2247  
2248    # BSTR prefix
2249    # the prefix for the namespace applying to the node
2250    def prefix()
2251      ret = _getproperty(33, [], [])
2252      @lastargs = WIN32OLE::ARGV
2253      ret
2254    end
2255  
2256    # BSTR baseName
2257    # the base name of the node (nodename with the prefix stripped off)
2258    def baseName()
2259      ret = _getproperty(34, [], [])
2260      @lastargs = WIN32OLE::ARGV
2261      ret
2262    end
2263  
2264    # VOID nodeValue
2265    # value stored in the node
2266    def nodeValue=(arg0)
2267      ret = _setproperty(3, [arg0], [VT_VARIANT])
2268      @lastargs = WIN32OLE::ARGV
2269      ret
2270    end
2271  
2272    # VOID text
2273    # text content of the node and subtree
2274    def text=(arg0)
2275      ret = _setproperty(24, [arg0], [VT_BSTR])
2276      @lastargs = WIN32OLE::ARGV
2277      ret
2278    end
2279  
2280    # VOID nodeTypedValue
2281    # get the strongly typed value of the node
2282    def nodeTypedValue=(arg0)
2283      ret = _setproperty(25, [arg0], [VT_VARIANT])
2284      @lastargs = WIN32OLE::ARGV
2285      ret
2286    end
2287  
2288    # VOID dataType
2289    # the data type of the node
2290    def dataType=(arg0)
2291      ret = _setproperty(26, [arg0], [VT_VARIANT])
2292      @lastargs = WIN32OLE::ARGV
2293      ret
2294    end
2295  
2296    # IXMLDOMNode insertBefore
2297    # insert a child node
2298    #   IXMLDOMNode arg0 --- newChild [IN]
2299    #   VARIANT arg1 --- refChild [IN]
2300    def insertBefore(arg0, arg1)
2301      ret = _invoke(13, [arg0, arg1], [VT_BYREF|VT_DISPATCH, VT_VARIANT])
2302      @lastargs = WIN32OLE::ARGV
2303      ret
2304    end
2305  
2306    # IXMLDOMNode replaceChild
2307    # replace a child node
2308    #   IXMLDOMNode arg0 --- newChild [IN]
2309    #   IXMLDOMNode arg1 --- oldChild [IN]
2310    def replaceChild(arg0, arg1)
2311      ret = _invoke(14, [arg0, arg1], [VT_BYREF|VT_DISPATCH, VT_BYREF|VT_DISPATCH])
2312      @lastargs = WIN32OLE::ARGV
2313      ret
2314    end
2315  
2316    # IXMLDOMNode removeChild
2317    # remove a child node
2318    #   IXMLDOMNode arg0 --- childNode [IN]
2319    def removeChild(arg0)
2320      ret = _invoke(15, [arg0], [VT_BYREF|VT_DISPATCH])
2321      @lastargs = WIN32OLE::ARGV
2322      ret
2323    end
2324  
2325    # IXMLDOMNode appendChild
2326    # append a child node
2327    #   IXMLDOMNode arg0 --- newChild [IN]
2328    def appendChild(arg0)
2329      ret = _invoke(16, [arg0], [VT_BYREF|VT_DISPATCH])
2330      @lastargs = WIN32OLE::ARGV
2331      ret
2332    end
2333  
2334    # BOOL hasChildNodes
2335    def hasChildNodes()
2336      ret = _invoke(17, [], [])
2337      @lastargs = WIN32OLE::ARGV
2338      ret
2339    end
2340  
2341    # IXMLDOMNode cloneNode
2342    #   BOOL arg0 --- deep [IN]
2343    def cloneNode(arg0)
2344      ret = _invoke(19, [arg0], [VT_BOOL])
2345      @lastargs = WIN32OLE::ARGV
2346      ret
2347    end
2348  
2349    # BSTR transformNode
2350    # apply the stylesheet to the subtree
2351    #   IXMLDOMNode arg0 --- stylesheet [IN]
2352    def transformNode(arg0)
2353      ret = _invoke(28, [arg0], [VT_BYREF|VT_DISPATCH])
2354      @lastargs = WIN32OLE::ARGV
2355      ret
2356    end
2357  
2358    # IXMLDOMNodeList selectNodes
2359    # execute query on the subtree
2360    #   BSTR arg0 --- queryString [IN]
2361    def selectNodes(arg0)
2362      ret = _invoke(29, [arg0], [VT_BSTR])
2363      @lastargs = WIN32OLE::ARGV
2364      ret
2365    end
2366  
2367    # IXMLDOMNode selectSingleNode
2368    # execute query on the subtree
2369    #   BSTR arg0 --- queryString [IN]
2370    def selectSingleNode(arg0)
2371      ret = _invoke(30, [arg0], [VT_BSTR])
2372      @lastargs = WIN32OLE::ARGV
2373      ret
2374    end
2375  
2376    # VOID transformNodeToObject
2377    # apply the stylesheet to the subtree, returning the result through a document or a stream
2378    #   IXMLDOMNode arg0 --- stylesheet [IN]
2379    #   VARIANT arg1 --- outputObject [IN]
2380    def transformNodeToObject(arg0, arg1)
2381      ret = _invoke(35, [arg0, arg1], [VT_BYREF|VT_DISPATCH, VT_VARIANT])
2382      @lastargs = WIN32OLE::ARGV
2383      ret
2384    end
2385  end
2386  
2387  # 
2388  module IXMLDOMText
2389    include WIN32OLE::VARIANT
2390    attr_reader :lastargs
2391  
2392    # BSTR nodeName
2393    # name of the node
2394    def nodeName()
2395      ret = _getproperty(2, [], [])
2396      @lastargs = WIN32OLE::ARGV
2397      ret
2398    end
2399  
2400    # VARIANT nodeValue
2401    # value stored in the node
2402    def nodeValue()
2403      ret = _getproperty(3, [], [])
2404      @lastargs = WIN32OLE::ARGV
2405      ret
2406    end
2407  
2408    # DOMNodeType nodeType
2409    # the node's type
2410    def nodeType()
2411      ret = _getproperty(4, [], [])
2412      @lastargs = WIN32OLE::ARGV
2413      ret
2414    end
2415  
2416    # IXMLDOMNode parentNode
2417    # parent of the node
2418    def parentNode()
2419      ret = _getproperty(6, [], [])
2420      @lastargs = WIN32OLE::ARGV
2421      ret
2422    end
2423  
2424    # IXMLDOMNodeList childNodes
2425    # the collection of the node's children
2426    def childNodes()
2427      ret = _getproperty(7, [], [])
2428      @lastargs = WIN32OLE::ARGV
2429      ret
2430    end
2431  
2432    # IXMLDOMNode firstChild
2433    # first child of the node
2434    def firstChild()
2435      ret = _getproperty(8, [], [])
2436      @lastargs = WIN32OLE::ARGV
2437      ret
2438    end
2439  
2440    # IXMLDOMNode lastChild
2441    # first child of the node
2442    def lastChild()
2443      ret = _getproperty(9, [], [])
2444      @lastargs = WIN32OLE::ARGV
2445      ret
2446    end
2447  
2448    # IXMLDOMNode previousSibling
2449    # left sibling of the node
2450    def previousSibling()
2451      ret = _getproperty(10, [], [])
2452      @lastargs = WIN32OLE::ARGV
2453      ret
2454    end
2455  
2456    # IXMLDOMNode nextSibling
2457    # right sibling of the node
2458    def nextSibling()
2459      ret = _getproperty(11, [], [])
2460      @lastargs = WIN32OLE::ARGV
2461      ret
2462    end
2463  
2464    # IXMLDOMNamedNodeMap attributes
2465    # the collection of the node's attributes
2466    def attributes()
2467      ret = _getproperty(12, [], [])
2468      @lastargs = WIN32OLE::ARGV
2469      ret
2470    end
2471  
2472    # IXMLDOMDocument ownerDocument
2473    # document that contains the node
2474    def ownerDocument()
2475      ret = _getproperty(18, [], [])
2476      @lastargs = WIN32OLE::ARGV
2477      ret
2478    end
2479  
2480    # BSTR nodeTypeString
2481    # the type of node in string form
2482    def nodeTypeString()
2483      ret = _getproperty(21, [], [])
2484      @lastargs = WIN32OLE::ARGV
2485      ret
2486    end
2487  
2488    # BSTR text
2489    # text content of the node and subtree
2490    def text()
2491      ret = _getproperty(24, [], [])
2492      @lastargs = WIN32OLE::ARGV
2493      ret
2494    end
2495  
2496    # BOOL specified
2497    # indicates whether node is a default value
2498    def specified()
2499      ret = _getproperty(22, [], [])
2500      @lastargs = WIN32OLE::ARGV
2501      ret
2502    end
2503  
2504    # IXMLDOMNode definition
2505    # pointer to the definition of the node in the DTD or schema
2506    def definition()
2507      ret = _getproperty(23, [], [])
2508      @lastargs = WIN32OLE::ARGV
2509      ret
2510    end
2511  
2512    # VARIANT nodeTypedValue
2513    # get the strongly typed value of the node
2514    def nodeTypedValue()
2515      ret = _getproperty(25, [], [])
2516      @lastargs = WIN32OLE::ARGV
2517      ret
2518    end
2519  
2520    # VARIANT dataType
2521    # the data type of the node
2522    def dataType()
2523      ret = _getproperty(26, [], [])
2524      @lastargs = WIN32OLE::ARGV
2525      ret
2526    end
2527  
2528    # BSTR xml
2529    # return the XML source for the node and each of its descendants
2530    def xml()
2531      ret = _getproperty(27, [], [])
2532      @lastargs = WIN32OLE::ARGV
2533      ret
2534    end
2535  
2536    # BOOL parsed
2537    # has sub-tree been completely parsed
2538    def parsed()
2539      ret = _getproperty(31, [], [])
2540      @lastargs = WIN32OLE::ARGV
2541      ret
2542    end
2543  
2544    # BSTR namespaceURI
2545    # the URI for the namespace applying to the node
2546    def namespaceURI()
2547      ret = _getproperty(32, [], [])
2548      @lastargs = WIN32OLE::ARGV
2549      ret
2550    end
2551  
2552    # BSTR prefix
2553    # the prefix for the namespace applying to the node
2554    def prefix()
2555      ret = _getproperty(33, [], [])
2556      @lastargs = WIN32OLE::ARGV
2557      ret
2558    end
2559  
2560    # BSTR baseName
2561    # the base name of the node (nodename with the prefix stripped off)
2562    def baseName()
2563      ret = _getproperty(34, [], [])
2564      @lastargs = WIN32OLE::ARGV
2565      ret
2566    end
2567  
2568    # BSTR data
2569    # value of the node
2570    def data()
2571      ret = _getproperty(109, [], [])
2572      @lastargs = WIN32OLE::ARGV
2573      ret
2574    end
2575  
2576    # I4 length
2577    # number of characters in value
2578    def length()
2579      ret = _getproperty(110, [], [])
2580      @lastargs = WIN32OLE::ARGV
2581      ret
2582    end
2583  
2584    # VOID nodeValue
2585    # value stored in the node
2586    def nodeValue=(arg0)
2587      ret = _setproperty(3, [arg0], [VT_VARIANT])
2588      @lastargs = WIN32OLE::ARGV
2589      ret
2590    end
2591  
2592    # VOID text
2593    # text content of the node and subtree
2594    def text=(arg0)
2595      ret = _setproperty(24, [arg0], [VT_BSTR])
2596      @lastargs = WIN32OLE::ARGV
2597      ret
2598    end
2599  
2600    # VOID nodeTypedValue
2601    # get the strongly typed value of the node
2602    def nodeTypedValue=(arg0)
2603      ret = _setproperty(25, [arg0], [VT_VARIANT])
2604      @lastargs = WIN32OLE::ARGV
2605      ret
2606    end
2607  
2608    # VOID dataType
2609    # the data type of the node
2610    def dataType=(arg0)
2611      ret = _setproperty(26, [arg0], [VT_VARIANT])
2612      @lastargs = WIN32OLE::ARGV
2613      ret
2614    end
2615  
2616    # VOID data
2617    # value of the node
2618    def data=(arg0)
2619      ret = _setproperty(109, [arg0], [VT_BSTR])
2620      @lastargs = WIN32OLE::ARGV
2621      ret
2622    end
2623  
2624    # IXMLDOMNode insertBefore
2625    # insert a child node
2626    #   IXMLDOMNode arg0 --- newChild [IN]
2627    #   VARIANT arg1 --- refChild [IN]
2628    def insertBefore(arg0, arg1)
2629      ret = _invoke(13, [arg0, arg1], [VT_BYREF|VT_DISPATCH, VT_VARIANT])
2630      @lastargs = WIN32OLE::ARGV
2631      ret
2632    end
2633  
2634    # IXMLDOMNode replaceChild
2635    # replace a child node
2636    #   IXMLDOMNode arg0 --- newChild [IN]
2637    #   IXMLDOMNode arg1 --- oldChild [IN]
2638    def replaceChild(arg0, arg1)
2639      ret = _invoke(14, [arg0, arg1], [VT_BYREF|VT_DISPATCH, VT_BYREF|VT_DISPATCH])
2640      @lastargs = WIN32OLE::ARGV
2641      ret
2642    end
2643  
2644    # IXMLDOMNode removeChild
2645    # remove a child node
2646    #   IXMLDOMNode arg0 --- childNode [IN]
2647    def removeChild(arg0)
2648      ret = _invoke(15, [arg0], [VT_BYREF|VT_DISPATCH])
2649      @lastargs = WIN32OLE::ARGV
2650      ret
2651    end
2652  
2653    # IXMLDOMNode appendChild
2654    # append a child node
2655    #   IXMLDOMNode arg0 --- newChild [IN]
2656    def appendChild(arg0)
2657      ret = _invoke(16, [arg0], [VT_BYREF|VT_DISPATCH])
2658      @lastargs = WIN32OLE::ARGV
2659      ret
2660    end
2661  
2662    # BOOL hasChildNodes
2663    def hasChildNodes()
2664      ret = _invoke(17, [], [])
2665      @lastargs = WIN32OLE::ARGV
2666      ret
2667    end
2668  
2669    # IXMLDOMNode cloneNode
2670    #   BOOL arg0 --- deep [IN]
2671    def cloneNode(arg0)
2672      ret = _invoke(19, [arg0], [VT_BOOL])
2673      @lastargs = WIN32OLE::ARGV
2674      ret
2675    end
2676  
2677    # BSTR transformNode
2678    # apply the stylesheet to the subtree
2679    #   IXMLDOMNode arg0 --- stylesheet [IN]
2680    def transformNode(arg0)
2681      ret = _invoke(28, [arg0], [VT_BYREF|VT_DISPATCH])
2682      @lastargs = WIN32OLE::ARGV
2683      ret
2684    end
2685  
2686    # IXMLDOMNodeList selectNodes
2687    # execute query on the subtree
2688    #   BSTR arg0 --- queryString [IN]
2689    def selectNodes(arg0)
2690      ret = _invoke(29, [arg0], [VT_BSTR])
2691      @lastargs = WIN32OLE::ARGV
2692      ret
2693    end
2694  
2695    # IXMLDOMNode selectSingleNode
2696    # execute query on the subtree
2697    #   BSTR arg0 --- queryString [IN]
2698    def selectSingleNode(arg0)
2699      ret = _invoke(30, [arg0], [VT_BSTR])
2700      @lastargs = WIN32OLE::ARGV
2701      ret
2702    end
2703  
2704    # VOID transformNodeToObject
2705    # apply the stylesheet to the subtree, returning the result through a document or a stream
2706    #   IXMLDOMNode arg0 --- stylesheet [IN]
2707    #   VARIANT arg1 --- outputObject [IN]
2708    def transformNodeToObject(arg0, arg1)
2709      ret = _invoke(35, [arg0, arg1], [VT_BYREF|VT_DISPATCH, VT_VARIANT])
2710      @lastargs = WIN32OLE::ARGV
2711      ret
2712    end
2713  
2714    # BSTR substringData
2715    # retrieve substring of value
2716    #   I4 arg0 --- offset [IN]
2717    #   I4 arg1 --- count [IN]
2718    def substringData(arg0, arg1)
2719      ret = _invoke(111, [arg0, arg1], [VT_I4, VT_I4])
2720      @lastargs = WIN32OLE::ARGV
2721      ret
2722    end
2723  
2724    # VOID appendData
2725    # append string to value
2726    #   BSTR arg0 --- data [IN]
2727    def appendData(arg0)
2728      ret = _invoke(112, [arg0], [VT_BSTR])
2729      @lastargs = WIN32OLE::ARGV
2730      ret
2731    end
2732  
2733    # VOID insertData
2734    # insert string into value
2735    #   I4 arg0 --- offset [IN]
2736    #   BSTR arg1 --- data [IN]
2737    def insertData(arg0, arg1)
2738      ret = _invoke(113, [arg0, arg1], [VT_I4, VT_BSTR])
2739      @lastargs = WIN32OLE::ARGV
2740      ret
2741    end
2742  
2743    # VOID deleteData
2744    # delete string within the value
2745    #   I4 arg0 --- offset [IN]
2746    #   I4 arg1 --- count [IN]
2747    def deleteData(arg0, arg1)
2748      ret = _invoke(114, [arg0, arg1], [VT_I4, VT_I4])
2749      @lastargs = WIN32OLE::ARGV
2750      ret
2751    end
2752  
2753    # VOID replaceData
2754    # replace string within the value
2755    #   I4 arg0 --- offset [IN]
2756    #   I4 arg1 --- count [IN]
2757    #   BSTR arg2 --- data [IN]
2758    def replaceData(arg0, arg1, arg2)
2759      ret = _invoke(115, [arg0, arg1, arg2], [VT_I4, VT_I4, VT_BSTR])
2760      @lastargs = WIN32OLE::ARGV
2761      ret
2762    end
2763  
2764    # IXMLDOMText splitText
2765    # split the text node into two text nodes at the position specified
2766    #   I4 arg0 --- offset [IN]
2767    def splitText(arg0)
2768      ret = _invoke(123, [arg0], [VT_I4])
2769      @lastargs = WIN32OLE::ARGV
2770      ret
2771    end
2772  end
2773  
2774  # 
2775  module IXMLDOMCharacterData
2776    include WIN32OLE::VARIANT
2777    attr_reader :lastargs
2778  
2779    # BSTR nodeName
2780    # name of the node
2781    def nodeName()
2782      ret = _getproperty(2, [], [])
2783      @lastargs = WIN32OLE::ARGV
2784      ret
2785    end
2786  
2787    # VARIANT nodeValue
2788    # value stored in the node
2789    def nodeValue()
2790      ret = _getproperty(3, [], [])
2791      @lastargs = WIN32OLE::ARGV
2792      ret
2793    end
2794  
2795    # DOMNodeType nodeType
2796    # the node's type
2797    def nodeType()
2798      ret = _getproperty(4, [], [])
2799      @lastargs = WIN32OLE::ARGV
2800      ret
2801    end
2802  
2803    # IXMLDOMNode parentNode
2804    # parent of the node
2805    def parentNode()
2806      ret = _getproperty(6, [], [])
2807      @lastargs = WIN32OLE::ARGV
2808      ret
2809    end
2810  
2811    # IXMLDOMNodeList childNodes
2812    # the collection of the node's children
2813    def childNodes()
2814      ret = _getproperty(7, [], [])
2815      @lastargs = WIN32OLE::ARGV
2816      ret
2817    end
2818  
2819    # IXMLDOMNode firstChild
2820    # first child of the node
2821    def firstChild()
2822      ret = _getproperty(8, [], [])
2823      @lastargs = WIN32OLE::ARGV
2824      ret
2825    end
2826  
2827    # IXMLDOMNode lastChild
2828    # first child of the node
2829    def lastChild()
2830      ret = _getproperty(9, [], [])
2831      @lastargs = WIN32OLE::ARGV
2832      ret
2833    end
2834  
2835    # IXMLDOMNode previousSibling
2836    # left sibling of the node
2837    def previousSibling()
2838      ret = _getproperty(10, [], [])
2839      @lastargs = WIN32OLE::ARGV
2840      ret
2841    end
2842  
2843    # IXMLDOMNode nextSibling
2844    # right sibling of the node
2845    def nextSibling()
2846      ret = _getproperty(11, [], [])
2847      @lastargs = WIN32OLE::ARGV
2848      ret
2849    end
2850  
2851    # IXMLDOMNamedNodeMap attributes
2852    # the collection of the node's attributes
2853    def attributes()
2854      ret = _getproperty(12, [], [])
2855      @lastargs = WIN32OLE::ARGV
2856      ret
2857    end
2858  
2859    # IXMLDOMDocument ownerDocument
2860    # document that contains the node
2861    def ownerDocument()
2862      ret = _getproperty(18, [], [])
2863      @lastargs = WIN32OLE::ARGV
2864      ret
2865    end
2866  
2867    # BSTR nodeTypeString
2868    # the type of node in string form
2869    def nodeTypeString()
2870      ret = _getproperty(21, [], [])
2871      @lastargs = WIN32OLE::ARGV
2872      ret
2873    end
2874  
2875    # BSTR text
2876    # text content of the node and subtree
2877    def text()
2878      ret = _getproperty(24, [], [])
2879      @lastargs = WIN32OLE::ARGV
2880      ret
2881    end
2882  
2883    # BOOL specified
2884    # indicates whether node is a default value
2885    def specified()
2886      ret = _getproperty(22, [], [])
2887      @lastargs = WIN32OLE::ARGV
2888      ret
2889    end
2890  
2891    # IXMLDOMNode definition
2892    # pointer to the definition of the node in the DTD or schema
2893    def definition()
2894      ret = _getproperty(23, [], [])
2895      @lastargs = WIN32OLE::ARGV
2896      ret
2897    end
2898  
2899    # VARIANT nodeTypedValue
2900    # get the strongly typed value of the node
2901    def nodeTypedValue()
2902      ret = _getproperty(25, [], [])
2903      @lastargs = WIN32OLE::ARGV
2904      ret
2905    end
2906  
2907    # VARIANT dataType
2908    # the data type of the node
2909    def dataType()
2910      ret = _getproperty(26, [], [])
2911      @lastargs = WIN32OLE::ARGV
2912      ret
2913    end
2914  
2915    # BSTR xml
2916    # return the XML source for the node and each of its descendants
2917    def xml()
2918      ret = _getproperty(27, [], [])
2919      @lastargs = WIN32OLE::ARGV
2920      ret
2921    end
2922  
2923    # BOOL parsed
2924    # has sub-tree been completely parsed
2925    def parsed()
2926      ret = _getproperty(31, [], [])
2927      @lastargs = WIN32OLE::ARGV
2928      ret
2929    end
2930  
2931    # BSTR namespaceURI
2932    # the URI for the namespace applying to the node
2933    def namespaceURI()
2934      ret = _getproperty(32, [], [])
2935      @lastargs = WIN32OLE::ARGV
2936      ret
2937    end
2938  
2939    # BSTR prefix
2940    # the prefix for the namespace applying to the node
2941    def prefix()
2942      ret = _getproperty(33, [], [])
2943      @lastargs = WIN32OLE::ARGV
2944      ret
2945    end
2946  
2947    # BSTR baseName
2948    # the base name of the node (nodename with the prefix stripped off)
2949    def baseName()
2950      ret = _getproperty(34, [], [])
2951      @lastargs = WIN32OLE::ARGV
2952      ret
2953    end
2954  
2955    # BSTR data
2956    # value of the node
2957    def data()
2958      ret = _getproperty(109, [], [])
2959      @lastargs = WIN32OLE::ARGV
2960      ret
2961    end
2962  
2963    # I4 length
2964    # number of characters in value
2965    def length()
2966      ret = _getproperty(110, [], [])
2967      @lastargs = WIN32OLE::ARGV
2968      ret
2969    end
2970  
2971    # VOID nodeValue
2972    # value stored in the node
2973    def nodeValue=(arg0)
2974      ret = _setproperty(3, [arg0], [VT_VARIANT])
2975      @lastargs = WIN32OLE::ARGV
2976      ret
2977    end
2978  
2979    # VOID text
2980    # text content of the node and subtree
2981    def text=(arg0)
2982      ret = _setproperty(24, [arg0], [VT_BSTR])
2983      @lastargs = WIN32OLE::ARGV
2984      ret
2985    end
2986  
2987    # VOID nodeTypedValue
2988    # get the strongly typed value of the node
2989    def nodeTypedValue=(arg0)
2990      ret = _setproperty(25, [arg0], [VT_VARIANT])
2991      @lastargs = WIN32OLE::ARGV
2992      ret
2993    end
2994  
2995    # VOID dataType
2996    # the data type of the node
2997    def dataType=(arg0)
2998      ret = _setproperty(26, [arg0], [VT_VARIANT])
2999      @lastargs = WIN32OLE::ARGV
3000      ret
3001    end
3002  
3003    # VOID data
3004    # value of the node
3005    def data=(arg0)
3006      ret = _setproperty(109, [arg0], [VT_BSTR])
3007      @lastargs = WIN32OLE::ARGV
3008      ret
3009    end
3010  
3011    # IXMLDOMNode insertBefore
3012    # insert a child node
3013    #   IXMLDOMNode arg0 --- newChild [IN]
3014    #   VARIANT arg1 --- refChild [IN]
3015    def insertBefore(arg0, arg1)
3016      ret = _invoke(13, [arg0, arg1], [VT_BYREF|VT_DISPATCH, VT_VARIANT])
3017      @lastargs = WIN32OLE::ARGV
3018      ret
3019    end
3020  
3021    # IXMLDOMNode replaceChild
3022    # replace a child node
3023    #   IXMLDOMNode arg0 --- newChild [IN]
3024    #   IXMLDOMNode arg1 --- oldChild [IN]
3025    def replaceChild(arg0, arg1)
3026      ret = _invoke(14, [arg0, arg1], [VT_BYREF|VT_DISPATCH, VT_BYREF|VT_DISPATCH])
3027      @lastargs = WIN32OLE::ARGV
3028      ret
3029    end
3030  
3031    # IXMLDOMNode removeChild
3032    # remove a child node
3033    #   IXMLDOMNode arg0 --- childNode [IN]
3034    def removeChild(arg0)
3035      ret = _invoke(15, [arg0], [VT_BYREF|VT_DISPATCH])
3036      @lastargs = WIN32OLE::ARGV
3037      ret
3038    end
3039  
3040    # IXMLDOMNode appendChild
3041    # append a child node
3042    #   IXMLDOMNode arg0 --- newChild [IN]
3043    def appendChild(arg0)
3044      ret = _invoke(16, [arg0], [VT_BYREF|VT_DISPATCH])
3045      @lastargs = WIN32OLE::ARGV
3046      ret
3047    end
3048  
3049    # BOOL hasChildNodes
3050    def hasChildNodes()
3051      ret = _invoke(17, [], [])
3052      @lastargs = WIN32OLE::ARGV
3053      ret
3054    end
3055  
3056    # IXMLDOMNode cloneNode
3057    #   BOOL arg0 --- deep [IN]
3058    def cloneNode(arg0)
3059      ret = _invoke(19, [arg0], [VT_BOOL])
3060      @lastargs = WIN32OLE::ARGV
3061      ret
3062    end
3063  
3064    # BSTR transformNode
3065    # apply the stylesheet to the subtree
3066    #   IXMLDOMNode arg0 --- stylesheet [IN]
3067    def transformNode(arg0)
3068      ret = _invoke(28, [arg0], [VT_BYREF|VT_DISPATCH])
3069      @lastargs = WIN32OLE::ARGV
3070      ret
3071    end
3072  
3073    # IXMLDOMNodeList selectNodes
3074    # execute query on the subtree
3075    #   BSTR arg0 --- queryString [IN]
3076    def selectNodes(arg0)
3077      ret = _invoke(29, [arg0], [VT_BSTR])
3078      @lastargs = WIN32OLE::ARGV
3079      ret
3080    end
3081  
3082    # IXMLDOMNode selectSingleNode
3083    # execute query on the subtree
3084    #   BSTR arg0 --- queryString [IN]
3085    def selectSingleNode(arg0)
3086      ret = _invoke(30, [arg0], [VT_BSTR])
3087      @lastargs = WIN32OLE::ARGV
3088      ret
3089    end
3090  
3091    # VOID transformNodeToObject
3092    # apply the stylesheet to the subtree, returning the result through a document or a stream
3093    #   IXMLDOMNode arg0 --- stylesheet [IN]
3094    #   VARIANT arg1 --- outputObject [IN]
3095    def transformNodeToObject(arg0, arg1)
3096      ret = _invoke(35, [arg0, arg1], [VT_BYREF|VT_DISPATCH, VT_VARIANT])
3097      @lastargs = WIN32OLE::ARGV
3098      ret
3099    end
3100  
3101    # BSTR substringData
3102    # retrieve substring of value
3103    #   I4 arg0 --- offset [IN]
3104    #   I4 arg1 --- count [IN]
3105    def substringData(arg0, arg1)
3106      ret = _invoke(111, [arg0, arg1], [VT_I4, VT_I4])
3107      @lastargs = WIN32OLE::ARGV
3108      ret
3109    end
3110  
3111    # VOID appendData
3112    # append string to value
3113    #   BSTR arg0 --- data [IN]
3114    def appendData(arg0)
3115      ret = _invoke(112, [arg0], [VT_BSTR])
3116      @lastargs = WIN32OLE::ARGV
3117      ret
3118    end
3119  
3120    # VOID insertData
3121    # insert string into value
3122    #   I4 arg0 --- offset [IN]
3123    #   BSTR arg1 --- data [IN]
3124    def insertData(arg0, arg1)
3125      ret = _invoke(113, [arg0, arg1], [VT_I4, VT_BSTR])
3126      @lastargs = WIN32OLE::ARGV
3127      ret
3128    end
3129  
3130    # VOID deleteData
3131    # delete string within the value
3132    #   I4 arg0 --- offset [IN]
3133    #   I4 arg1 --- count [IN]
3134    def deleteData(arg0, arg1)
3135      ret = _invoke(114, [arg0, arg1], [VT_I4, VT_I4])
3136      @lastargs = WIN32OLE::ARGV
3137      ret
3138    end
3139  
3140    # VOID replaceData
3141    # replace string within the value
3142    #   I4 arg0 --- offset [IN]
3143    #   I4 arg1 --- count [IN]
3144    #   BSTR arg2 --- data [IN]
3145    def replaceData(arg0, arg1, arg2)
3146      ret = _invoke(115, [arg0, arg1, arg2], [VT_I4, VT_I4, VT_BSTR])
3147      @lastargs = WIN32OLE::ARGV
3148      ret
3149    end
3150  end
3151  
3152  # 
3153  module IXMLDOMComment
3154    include WIN32OLE::VARIANT
3155    attr_reader :lastargs
3156  
3157    # BSTR nodeName
3158    # name of the node
3159    def nodeName()
3160      ret = _getproperty(2, [], [])
3161      @lastargs = WIN32OLE::ARGV
3162      ret
3163    end
3164  
3165    # VARIANT nodeValue
3166    # value stored in the node
3167    def nodeValue()
3168      ret = _getproperty(3, [], [])
3169      @lastargs = WIN32OLE::ARGV
3170      ret
3171    end
3172  
3173    # DOMNodeType nodeType
3174    # the node's type
3175    def nodeType()
3176      ret = _getproperty(4, [], [])
3177      @lastargs = WIN32OLE::ARGV
3178      ret
3179    end
3180  
3181    # IXMLDOMNode parentNode
3182    # parent of the node
3183    def parentNode()
3184      ret = _getproperty(6, [], [])
3185      @lastargs = WIN32OLE::ARGV
3186      ret
3187    end
3188  
3189    # IXMLDOMNodeList childNodes
3190    # the collection of the node's children
3191    def childNodes()
3192      ret = _getproperty(7, [], [])
3193      @lastargs = WIN32OLE::ARGV
3194      ret
3195    end
3196  
3197    # IXMLDOMNode firstChild
3198    # first child of the node
3199    def firstChild()
3200      ret = _getproperty(8, [], [])
3201      @lastargs = WIN32OLE::ARGV
3202      ret
3203    end
3204  
3205    # IXMLDOMNode lastChild
3206    # first child of the node
3207    def lastChild()
3208      ret = _getproperty(9, [], [])
3209      @lastargs = WIN32OLE::ARGV
3210      ret
3211    end
3212  
3213    # IXMLDOMNode previousSibling
3214    # left sibling of the node
3215    def previousSibling()
3216      ret = _getproperty(10, [], [])
3217      @lastargs = WIN32OLE::ARGV
3218      ret
3219    end
3220  
3221    # IXMLDOMNode nextSibling
3222    # right sibling of the node
3223    def nextSibling()
3224      ret = _getproperty(11, [], [])
3225      @lastargs = WIN32OLE::ARGV
3226      ret
3227    end
3228  
3229    # IXMLDOMNamedNodeMap attributes
3230    # the collection of the node's attributes
3231    def attributes()
3232      ret = _getproperty(12, [], [])
3233      @lastargs = WIN32OLE::ARGV
3234      ret
3235    end
3236  
3237    # IXMLDOMDocument ownerDocument
3238    # document that contains the node
3239    def ownerDocument()
3240      ret = _getproperty(18, [], [])
3241      @lastargs = WIN32OLE::ARGV
3242      ret
3243    end
3244  
3245    # BSTR nodeTypeString
3246    # the type of node in string form
3247    def nodeTypeString()
3248      ret = _getproperty(21, [], [])
3249      @lastargs = WIN32OLE::ARGV
3250      ret
3251    end
3252  
3253    # BSTR text
3254    # text content of the node and subtree
3255    def text()
3256      ret = _getproperty(24, [], [])
3257      @lastargs = WIN32OLE::ARGV
3258      ret
3259    end
3260  
3261    # BOOL specified
3262    # indicates whether node is a default value
3263    def specified()
3264      ret = _getproperty(22, [], [])
3265      @lastargs = WIN32OLE::ARGV
3266      ret
3267    end
3268  
3269    # IXMLDOMNode definition
3270    # pointer to the definition of the node in the DTD or schema
3271    def definition()
3272      ret = _getproperty(23, [], [])
3273      @lastargs = WIN32OLE::ARGV
3274      ret
3275    end
3276  
3277    # VARIANT nodeTypedValue
3278    # get the strongly typed value of the node
3279    def nodeTypedValue()
3280      ret = _getproperty(25, [], [])
3281      @lastargs = WIN32OLE::ARGV
3282      ret
3283    end
3284  
3285    # VARIANT dataType
3286    # the data type of the node
3287    def dataType()
3288      ret = _getproperty(26, [], [])
3289      @lastargs = WIN32OLE::ARGV
3290      ret
3291    end
3292  
3293    # BSTR xml
3294    # return the XML source for the node and each of its descendants
3295    def xml()
3296      ret = _getproperty(27, [], [])
3297      @lastargs = WIN32OLE::ARGV
3298      ret
3299    end
3300  
3301    # BOOL parsed
3302    # has sub-tree been completely parsed
3303    def parsed()
3304      ret = _getproperty(31, [], [])
3305      @lastargs = WIN32OLE::ARGV
3306      ret
3307    end
3308  
3309    # BSTR namespaceURI
3310    # the URI for the namespace applying to the node
3311    def namespaceURI()
3312      ret = _getproperty(32, [], [])
3313      @lastargs = WIN32OLE::ARGV
3314      ret
3315    end
3316  
3317    # BSTR prefix
3318    # the prefix for the namespace applying to the node
3319    def prefix()
3320      ret = _getproperty(33, [], [])
3321      @lastargs = WIN32OLE::ARGV
3322      ret
3323    end
3324  
3325    # BSTR baseName
3326    # the base name of the node (nodename with the prefix stripped off)
3327    def baseName()
3328      ret = _getproperty(34, [], [])
3329      @lastargs = WIN32OLE::ARGV
3330      ret
3331    end
3332  
3333    # BSTR data
3334    # value of the node
3335    def data()
3336      ret = _getproperty(109, [], [])
3337      @lastargs = WIN32OLE::ARGV
3338      ret
3339    end
3340  
3341    # I4 length
3342    # number of characters in value
3343    def length()
3344      ret = _getproperty(110, [], [])
3345      @lastargs = WIN32OLE::ARGV
3346      ret
3347    end
3348  
3349    # VOID nodeValue
3350    # value stored in the node
3351    def nodeValue=(arg0)
3352      ret = _setproperty(3, [arg0], [VT_VARIANT])
3353      @lastargs = WIN32OLE::ARGV
3354      ret
3355    end
3356  
3357    # VOID text
3358    # text content of the node and subtree
3359    def text=(arg0)
3360      ret = _setproperty(24, [arg0], [VT_BSTR])
3361      @lastargs = WIN32OLE::ARGV
3362      ret
3363    end
3364  
3365    # VOID nodeTypedValue
3366    # get the strongly typed value of the node
3367    def nodeTypedValue=(arg0)
3368      ret = _setproperty(25, [arg0], [VT_VARIANT])
3369      @lastargs = WIN32OLE::ARGV
3370      ret
3371    end
3372  
3373    # VOID dataType
3374    # the data type of the node
3375    def dataType=(arg0)
3376      ret = _setproperty(26, [arg0], [VT_VARIANT])
3377      @lastargs = WIN32OLE::ARGV
3378      ret
3379    end
3380  
3381    # VOID data
3382    # value of the node
3383    def data=(arg0)
3384      ret = _setproperty(109, [arg0], [VT_BSTR])
3385      @lastargs = WIN32OLE::ARGV
3386      ret
3387    end
3388  
3389    # IXMLDOMNode insertBefore
3390    # insert a child node
3391    #   IXMLDOMNode arg0 --- newChild [IN]
3392    #   VARIANT arg1 --- refChild [IN]
3393    def insertBefore(arg0, arg1)
3394      ret = _invoke(13, [arg0, arg1], [VT_BYREF|VT_DISPATCH, VT_VARIANT])
3395      @lastargs = WIN32OLE::ARGV
3396      ret
3397    end
3398  
3399    # IXMLDOMNode replaceChild
3400    # replace a child node
3401    #   IXMLDOMNode arg0 --- newChild [IN]
3402    #   IXMLDOMNode arg1 --- oldChild [IN]
3403    def replaceChild(arg0, arg1)
3404      ret = _invoke(14, [arg0, arg1], [VT_BYREF|VT_DISPATCH, VT_BYREF|VT_DISPATCH])
3405      @lastargs = WIN32OLE::ARGV
3406      ret
3407    end
3408  
3409    # IXMLDOMNode removeChild
3410    # remove a child node
3411    #   IXMLDOMNode arg0 --- childNode [IN]
3412    def removeChild(arg0)
3413      ret = _invoke(15, [arg0], [VT_BYREF|VT_DISPATCH])
3414      @lastargs = WIN32OLE::ARGV
3415      ret
3416    end
3417  
3418    # IXMLDOMNode appendChild
3419    # append a child node
3420    #   IXMLDOMNode arg0 --- newChild [IN]
3421    def appendChild(arg0)
3422      ret = _invoke(16, [arg0], [VT_BYREF|VT_DISPATCH])
3423      @lastargs = WIN32OLE::ARGV
3424      ret
3425    end
3426  
3427    # BOOL hasChildNodes
3428    def hasChildNodes()
3429      ret = _invoke(17, [], [])
3430      @lastargs = WIN32OLE::ARGV
3431      ret
3432    end
3433  
3434    # IXMLDOMNode cloneNode
3435    #   BOOL arg0 --- deep [IN]
3436    def cloneNode(arg0)
3437      ret = _invoke(19, [arg0], [VT_BOOL])
3438      @lastargs = WIN32OLE::ARGV
3439      ret
3440    end
3441  
3442    # BSTR transformNode
3443    # apply the stylesheet to the subtree
3444    #   IXMLDOMNode arg0 --- stylesheet [IN]
3445    def transformNode(arg0)
3446      ret = _invoke(28, [arg0], [VT_BYREF|VT_DISPATCH])
3447      @lastargs = WIN32OLE::ARGV
3448      ret
3449    end
3450  
3451    # IXMLDOMNodeList selectNodes
3452    # execute query on the subtree
3453    #   BSTR arg0 --- queryString [IN]
3454    def selectNodes(arg0)
3455      ret = _invoke(29, [arg0], [VT_BSTR])
3456      @lastargs = WIN32OLE::ARGV
3457      ret
3458    end
3459  
3460    # IXMLDOMNode selectSingleNode
3461    # execute query on the subtree
3462    #   BSTR arg0 --- queryString [IN]
3463    def selectSingleNode(arg0)
3464      ret = _invoke(30, [arg0], [VT_BSTR])
3465      @lastargs = WIN32OLE::ARGV
3466      ret
3467    end
3468  
3469    # VOID transformNodeToObject
3470    # apply the stylesheet to the subtree, returning the result through a document or a stream
3471    #   IXMLDOMNode arg0 --- stylesheet [IN]
3472    #   VARIANT arg1 --- outputObject [IN]
3473    def transformNodeToObject(arg0, arg1)
3474      ret = _invoke(35, [arg0, arg1], [VT_BYREF|VT_DISPATCH, VT_VARIANT])
3475      @lastargs = WIN32OLE::ARGV
3476      ret
3477    end
3478  
3479    # BSTR substringData
3480    # retrieve substring of value
3481    #   I4 arg0 --- offset [IN]
3482    #   I4 arg1 --- count [IN]
3483    def substringData(arg0, arg1)
3484      ret = _invoke(111, [arg0, arg1], [VT_I4, VT_I4])
3485      @lastargs = WIN32OLE::ARGV
3486      ret
3487    end
3488  
3489    # VOID appendData
3490    # append string to value
3491    #   BSTR arg0 --- data [IN]
3492    def appendData(arg0)
3493      ret = _invoke(112, [arg0], [VT_BSTR])
3494      @lastargs = WIN32OLE::ARGV
3495      ret
3496    end
3497  
3498    # VOID insertData
3499    # insert string into value
3500    #   I4 arg0 --- offset [IN]
3501    #   BSTR arg1 --- data [IN]
3502    def insertData(arg0, arg1)
3503      ret = _invoke(113, [arg0, arg1], [VT_I4, VT_BSTR])
3504      @lastargs = WIN32OLE::ARGV
3505      ret
3506    end
3507  
3508    # VOID deleteData
3509    # delete string within the value
3510    #   I4 arg0 --- offset [IN]
3511    #   I4 arg1 --- count [IN]
3512    def deleteData(arg0, arg1)
3513      ret = _invoke(114, [arg0, arg1], [VT_I4, VT_I4])
3514      @lastargs = WIN32OLE::ARGV
3515      ret
3516    end
3517  
3518    # VOID replaceData
3519    # replace string within the value
3520    #   I4 arg0 --- offset [IN]
3521    #   I4 arg1 --- count [IN]
3522    #   BSTR arg2 --- data [IN]
3523    def replaceData(arg0, arg1, arg2)
3524      ret = _invoke(115, [arg0, arg1, arg2], [VT_I4, VT_I4, VT_BSTR])
3525      @lastargs = WIN32OLE::ARGV
3526      ret
3527    end
3528  end
3529  
3530  # 
3531  module IXMLDOMCDATASection
3532    include WIN32OLE::VARIANT
3533    attr_reader :lastargs
3534  
3535    # BSTR nodeName
3536    # name of the node
3537    def nodeName()
3538      ret = _getproperty(2, [], [])
3539      @lastargs = WIN32OLE::ARGV
3540      ret
3541    end
3542  
3543    # VARIANT nodeValue
3544    # value stored in the node
3545    def nodeValue()
3546      ret = _getproperty(3, [], [])
3547      @lastargs = WIN32OLE::ARGV
3548      ret
3549    end
3550  
3551    # DOMNodeType nodeType
3552    # the node's type
3553    def nodeType()
3554      ret = _getproperty(4, [], [])
3555      @lastargs = WIN32OLE::ARGV
3556      ret
3557    end
3558  
3559    # IXMLDOMNode parentNode
3560    # parent of the node
3561    def parentNode()
3562      ret = _getproperty(6, [], [])
3563      @lastargs = WIN32OLE::ARGV
3564      ret
3565    end
3566  
3567    # IXMLDOMNodeList childNodes
3568    # the collection of the node's children
3569    def childNodes()
3570      ret = _getproperty(7, [], [])
3571      @lastargs = WIN32OLE::ARGV
3572      ret
3573    end
3574  
3575    # IXMLDOMNode firstChild
3576    # first child of the node
3577    def firstChild()
3578      ret = _getproperty(8, [], [])
3579      @lastargs = WIN32OLE::ARGV
3580      ret
3581    end
3582  
3583    # IXMLDOMNode lastChild
3584    # first child of the node
3585    def lastChild()
3586      ret = _getproperty(9, [], [])
3587      @lastargs = WIN32OLE::ARGV
3588      ret
3589    end
3590  
3591    # IXMLDOMNode previousSibling
3592    # left sibling of the node
3593    def previousSibling()
3594      ret = _getproperty(10, [], [])
3595      @lastargs = WIN32OLE::ARGV
3596      ret
3597    end
3598  
3599    # IXMLDOMNode nextSibling
3600    # right sibling of the node
3601    def nextSibling()
3602      ret = _getproperty(11, [], [])
3603      @lastargs = WIN32OLE::ARGV
3604      ret
3605    end
3606  
3607    # IXMLDOMNamedNodeMap attributes
3608    # the collection of the node's attributes
3609    def attributes()
3610      ret = _getproperty(12, [], [])
3611      @lastargs = WIN32OLE::ARGV
3612      ret
3613    end
3614  
3615    # IXMLDOMDocument ownerDocument
3616    # document that contains the node
3617    def ownerDocument()
3618      ret = _getproperty(18, [], [])
3619      @lastargs = WIN32OLE::ARGV
3620      ret
3621    end
3622  
3623    # BSTR nodeTypeString
3624    # the type of node in string form
3625    def nodeTypeString()
3626      ret = _getproperty(21, [], [])
3627      @lastargs = WIN32OLE::ARGV
3628      ret
3629    end
3630  
3631    # BSTR text
3632    # text content of the node and subtree
3633    def text()
3634      ret = _getproperty(24, [], [])
3635      @lastargs = WIN32OLE::ARGV
3636      ret
3637    end
3638  
3639    # BOOL specified
3640    # indicates whether node is a default value
3641    def specified()
3642      ret = _getproperty(22, [], [])
3643      @lastargs = WIN32OLE::ARGV
3644      ret
3645    end
3646  
3647    # IXMLDOMNode definition
3648    # pointer to the definition of the node in the DTD or schema
3649    def definition()
3650      ret = _getproperty(23, [], [])
3651      @lastargs = WIN32OLE::ARGV
3652      ret
3653    end
3654  
3655    # VARIANT nodeTypedValue
3656    # get the strongly typed value of the node
3657    def nodeTypedValue()
3658      ret = _getproperty(25, [], [])
3659      @lastargs = WIN32OLE::ARGV
3660      ret
3661    end
3662  
3663    # VARIANT dataType
3664    # the data type of the node
3665    def dataType()
3666      ret = _getproperty(26, [], [])
3667      @lastargs = WIN32OLE::ARGV
3668      ret
3669    end
3670  
3671    # BSTR xml
3672    # return the XML source for the node and each of its descendants
3673    def xml()
3674      ret = _getproperty(27, [], [])
3675      @lastargs = WIN32OLE::ARGV
3676      ret
3677    end
3678  
3679    # BOOL parsed
3680    # has sub-tree been completely parsed
3681    def parsed()
3682      ret = _getproperty(31, [], [])
3683      @lastargs = WIN32OLE::ARGV
3684      ret
3685    end
3686  
3687    # BSTR namespaceURI
3688    # the URI for the namespace applying to the node
3689    def namespaceURI()
3690      ret = _getproperty(32, [], [])
3691      @lastargs = WIN32OLE::ARGV
3692      ret
3693    end
3694  
3695    # BSTR prefix
3696    # the prefix for the namespace applying to the node
3697    def prefix()
3698      ret = _getproperty(33, [], [])
3699      @lastargs = WIN32OLE::ARGV
3700      ret
3701    end
3702  
3703    # BSTR baseName
3704    # the base name of the node (nodename with the prefix stripped off)
3705    def baseName()
3706      ret = _getproperty(34, [], [])
3707      @lastargs = WIN32OLE::ARGV
3708      ret
3709    end
3710  
3711    # BSTR data
3712    # value of the node
3713    def data()
3714      ret = _getproperty(109, [], [])
3715      @lastargs = WIN32OLE::ARGV
3716      ret
3717    end
3718  
3719    # I4 length
3720    # number of characters in value
3721    def length()
3722      ret = _getproperty(110, [], [])
3723      @lastargs = WIN32OLE::ARGV
3724      ret
3725    end
3726  
3727    # VOID nodeValue
3728    # value stored in the node
3729    def nodeValue=(arg0)
3730      ret = _setproperty(3, [arg0], [VT_VARIANT])
3731      @lastargs = WIN32OLE::ARGV
3732      ret
3733    end
3734  
3735    # VOID text
3736    # text content of the node and subtree
3737    def text=(arg0)
3738      ret = _setproperty(24, [arg0], [VT_BSTR])
3739      @lastargs = WIN32OLE::ARGV
3740      ret
3741    end
3742  
3743    # VOID nodeTypedValue
3744    # get the strongly typed value of the node
3745    def nodeTypedValue=(arg0)
3746      ret = _setproperty(25, [arg0], [VT_VARIANT])
3747      @lastargs = WIN32OLE::ARGV
3748      ret
3749    end
3750  
3751    # VOID dataType
3752    # the data type of the node
3753    def dataType=(arg0)
3754      ret = _setproperty(26, [arg0], [VT_VARIANT])
3755      @lastargs = WIN32OLE::ARGV
3756      ret
3757    end
3758  
3759    # VOID data
3760    # value of the node
3761    def data=(arg0)
3762      ret = _setproperty(109, [arg0], [VT_BSTR])
3763      @lastargs = WIN32OLE::ARGV
3764      ret
3765    end
3766  
3767    # IXMLDOMNode insertBefore
3768    # insert a child node
3769    #   IXMLDOMNode arg0 --- newChild [IN]
3770    #   VARIANT arg1 --- refChild [IN]
3771    def insertBefore(arg0, arg1)
3772      ret = _invoke(13, [arg0, arg1], [VT_BYREF|VT_DISPATCH, VT_VARIANT])
3773      @lastargs = WIN32OLE::ARGV
3774      ret
3775    end
3776  
3777    # IXMLDOMNode replaceChild
3778    # replace a child node
3779    #   IXMLDOMNode arg0 --- newChild [IN]
3780    #   IXMLDOMNode arg1 --- oldChild [IN]
3781    def replaceChild(arg0, arg1)
3782      ret = _invoke(14, [arg0, arg1], [VT_BYREF|VT_DISPATCH, VT_BYREF|VT_DISPATCH])
3783      @lastargs = WIN32OLE::ARGV
3784      ret
3785    end
3786  
3787    # IXMLDOMNode removeChild
3788    # remove a child node
3789    #   IXMLDOMNode arg0 --- childNode [IN]
3790    def removeChild(arg0)
3791      ret = _invoke(15, [arg0], [VT_BYREF|VT_DISPATCH])
3792      @lastargs = WIN32OLE::ARGV
3793      ret
3794    end
3795  
3796    # IXMLDOMNode appendChild
3797    # append a child node
3798    #   IXMLDOMNode arg0 --- newChild [IN]
3799    def appendChild(arg0)
3800      ret = _invoke(16, [arg0], [VT_BYREF|VT_DISPATCH])
3801      @lastargs = WIN32OLE::ARGV
3802      ret
3803    end
3804  
3805    # BOOL hasChildNodes
3806    def hasChildNodes()
3807      ret = _invoke(17, [], [])
3808      @lastargs = WIN32OLE::ARGV
3809      ret
3810    end
3811  
3812    # IXMLDOMNode cloneNode
3813    #   BOOL arg0 --- deep [IN]
3814    def cloneNode(arg0)
3815      ret = _invoke(19, [arg0], [VT_BOOL])
3816      @lastargs = WIN32OLE::ARGV
3817      ret
3818    end
3819  
3820    # BSTR transformNode
3821    # apply the stylesheet to the subtree
3822    #   IXMLDOMNode arg0 --- stylesheet [IN]
3823    def transformNode(arg0)
3824      ret = _invoke(28, [arg0], [VT_BYREF|VT_DISPATCH])
3825      @lastargs = WIN32OLE::ARGV
3826      ret
3827    end
3828  
3829    # IXMLDOMNodeList selectNodes
3830    # execute query on the subtree
3831    #   BSTR arg0 --- queryString [IN]
3832    def selectNodes(arg0)
3833      ret = _invoke(29, [arg0], [VT_BSTR])
3834      @lastargs = WIN32OLE::ARGV
3835      ret
3836    end
3837  
3838    # IXMLDOMNode selectSingleNode
3839    # execute query on the subtree
3840    #   BSTR arg0 --- queryString [IN]
3841    def selectSingleNode(arg0)
3842      ret = _invoke(30, [arg0], [VT_BSTR])
3843      @lastargs = WIN32OLE::ARGV
3844      ret
3845    end
3846  
3847    # VOID transformNodeToObject
3848    # apply the stylesheet to the subtree, returning the result through a document or a stream
3849    #   IXMLDOMNode arg0 --- stylesheet [IN]
3850    #   VARIANT arg1 --- outputObject [IN]
3851    def transformNodeToObject(arg0, arg1)
3852      ret = _invoke(35, [arg0, arg1], [VT_BYREF|VT_DISPATCH, VT_VARIANT])
3853      @lastargs = WIN32OLE::ARGV
3854      ret
3855    end
3856  
3857    # BSTR substringData
3858    # retrieve substring of value
3859    #   I4 arg0 --- offset [IN]
3860    #   I4 arg1 --- count [IN]
3861    def substringData(arg0, arg1)
3862      ret = _invoke(111, [arg0, arg1], [VT_I4, VT_I4])
3863      @lastargs = WIN32OLE::ARGV
3864      ret
3865    end
3866  
3867    # VOID appendData
3868    # append string to value
3869    #   BSTR arg0 --- data [IN]
3870    def appendData(arg0)
3871      ret = _invoke(112, [arg0], [VT_BSTR])
3872      @lastargs = WIN32OLE::ARGV
3873      ret
3874    end
3875  
3876    # VOID insertData
3877    # insert string into value
3878    #   I4 arg0 --- offset [IN]
3879    #   BSTR arg1 --- data [IN]
3880    def insertData(arg0, arg1)
3881      ret = _invoke(113, [arg0, arg1], [VT_I4, VT_BSTR])
3882      @lastargs = WIN32OLE::ARGV
3883      ret
3884    end
3885  
3886    # VOID deleteData
3887    # delete string within the value
3888    #   I4 arg0 --- offset [IN]
3889    #   I4 arg1 --- count [IN]
3890    def deleteData(arg0, arg1)
3891      ret = _invoke(114, [arg0, arg1], [VT_I4, VT_I4])
3892      @lastargs = WIN32OLE::ARGV
3893      ret
3894    end
3895  
3896    # VOID replaceData
3897    # replace string within the value
3898    #   I4 arg0 --- offset [IN]
3899    #   I4 arg1 --- count [IN]
3900    #   BSTR arg2 --- data [IN]
3901    def replaceData(arg0, arg1, arg2)
3902      ret = _invoke(115, [arg0, arg1, arg2], [VT_I4, VT_I4, VT_BSTR])
3903      @lastargs = WIN32OLE::ARGV
3904      ret
3905    end
3906  
3907    # IXMLDOMText splitText
3908    # split the text node into two text nodes at the position specified
3909    #   I4 arg0 --- offset [IN]
3910    def splitText(arg0)
3911      ret = _invoke(123, [arg0], [VT_I4])
3912      @lastargs = WIN32OLE::ARGV
3913      ret
3914    end
3915  end
3916  
3917  # 
3918  module IXMLDOMProcessingInstruction
3919    include WIN32OLE::VARIANT
3920    attr_reader :lastargs
3921  
3922    # BSTR nodeName
3923    # name of the node
3924    def nodeName()
3925      ret = _getproperty(2, [], [])
3926      @lastargs = WIN32OLE::ARGV
3927      ret
3928    end
3929  
3930    # VARIANT nodeValue
3931    # value stored in the node
3932    def nodeValue()
3933      ret = _getproperty(3, [], [])
3934      @lastargs = WIN32OLE::ARGV
3935      ret
3936    end
3937  
3938    # DOMNodeType nodeType
3939    # the node's type
3940    def nodeType()
3941      ret = _getproperty(4, [], [])
3942      @lastargs = WIN32OLE::ARGV
3943      ret
3944    end
3945  
3946    # IXMLDOMNode parentNode
3947    # parent of the node
3948    def parentNode()
3949      ret = _getproperty(6, [], [])
3950      @lastargs = WIN32OLE::ARGV
3951      ret
3952    end
3953  
3954    # IXMLDOMNodeList childNodes
3955    # the collection of the node's children
3956    def childNodes()
3957      ret = _getproperty(7, [], [])
3958      @lastargs = WIN32OLE::ARGV
3959      ret
3960    end
3961  
3962    # IXMLDOMNode firstChild
3963    # first child of the node
3964    def firstChild()
3965      ret = _getproperty(8, [], [])
3966      @lastargs = WIN32OLE::ARGV
3967      ret
3968    end
3969  
3970    # IXMLDOMNode lastChild
3971    # first child of the node
3972    def lastChild()
3973      ret = _getproperty(9, [], [])
3974      @lastargs = WIN32OLE::ARGV
3975      ret
3976    end
3977  
3978    # IXMLDOMNode previousSibling
3979    # left sibling of the node
3980    def previousSibling()
3981      ret = _getproperty(10, [], [])
3982      @lastargs = WIN32OLE::ARGV
3983      ret
3984    end
3985  
3986    # IXMLDOMNode nextSibling
3987    # right sibling of the node
3988    def nextSibling()
3989      ret = _getproperty(11, [], [])
3990      @lastargs = WIN32OLE::ARGV
3991      ret
3992    end
3993  
3994    # IXMLDOMNamedNodeMap attributes
3995    # the collection of the node's attributes
3996    def attributes()
3997      ret = _getproperty(12, [], [])
3998      @lastargs = WIN32OLE::ARGV
3999      ret
4000    end
4001  
4002    # IXMLDOMDocument ownerDocument
4003    # document that contains the node
4004    def ownerDocument()
4005      ret = _getproperty(18, [], [])
4006      @lastargs = WIN32OLE::ARGV
4007      ret
4008    end
4009  
4010    # BSTR nodeTypeString
4011    # the type of node in string form
4012    def nodeTypeString()
4013      ret = _getproperty(21, [], [])
4014      @lastargs = WIN32OLE::ARGV
4015      ret
4016    end
4017  
4018    # BSTR text
4019    # text content of the node and subtree
4020    def text()
4021      ret = _getproperty(24, [], [])
4022      @lastargs = WIN32OLE::ARGV
4023      ret
4024    end
4025  
4026    # BOOL specified
4027    # indicates whether node is a default value
4028    def specified()
4029      ret = _getproperty(22, [], [])
4030      @lastargs = WIN32OLE::ARGV
4031      ret
4032    end
4033  
4034    # IXMLDOMNode definition
4035    # pointer to the definition of the node in the DTD or schema
4036    def definition()
4037      ret = _getproperty(23, [], [])
4038      @lastargs = WIN32OLE::ARGV
4039      ret
4040    end
4041  
4042    # VARIANT nodeTypedValue
4043    # get the strongly typed value of the node
4044    def nodeTypedValue()
4045      ret = _getproperty(25, [], [])
4046      @lastargs = WIN32OLE::ARGV
4047      ret
4048    end
4049  
4050    # VARIANT dataType
4051    # the data type of the node
4052    def dataType()
4053      ret = _getproperty(26, [], [])
4054      @lastargs = WIN32OLE::ARGV
4055      ret
4056    end
4057  
4058    # BSTR xml
4059    # return the XML source for the node and each of its descendants
4060    def xml()
4061      ret = _getproperty(27, [], [])
4062      @lastargs = WIN32OLE::ARGV
4063      ret
4064    end
4065  
4066    # BOOL parsed
4067    # has sub-tree been completely parsed
4068    def parsed()
4069      ret = _getproperty(31, [], [])
4070      @lastargs = WIN32OLE::ARGV
4071      ret
4072    end
4073  
4074    # BSTR namespaceURI
4075    # the URI for the namespace applying to the node
4076    def namespaceURI()
4077      ret = _getproperty(32, [], [])
4078      @lastargs = WIN32OLE::ARGV
4079      ret
4080    end
4081  
4082    # BSTR prefix
4083    # the prefix for the namespace applying to the node
4084    def prefix()
4085      ret = _getproperty(33, [], [])
4086      @lastargs = WIN32OLE::ARGV
4087      ret
4088    end
4089  
4090    # BSTR baseName
4091    # the base name of the node (nodename with the prefix stripped off)
4092    def baseName()
4093      ret = _getproperty(34, [], [])
4094      @lastargs = WIN32OLE::ARGV
4095      ret
4096    end
4097  
4098    # BSTR target
4099    # the target
4100    def target()
4101      ret = _getproperty(127, [], [])
4102      @lastargs = WIN32OLE::ARGV
4103      ret
4104    end
4105  
4106    # BSTR data
4107    # the data
4108    def data()
4109      ret = _getproperty(128, [], [])
4110      @lastargs = WIN32OLE::ARGV
4111      ret
4112    end
4113  
4114    # VOID nodeValue
4115    # value stored in the node
4116    def nodeValue=(arg0)
4117      ret = _setproperty(3, [arg0], [VT_VARIANT])
4118      @lastargs = WIN32OLE::ARGV
4119      ret
4120    end
4121  
4122    # VOID text
4123    # text content of the node and subtree
4124    def text=(arg0)
4125      ret = _setproperty(24, [arg0], [VT_BSTR])
4126      @lastargs = WIN32OLE::ARGV
4127      ret
4128    end
4129  
4130    # VOID nodeTypedValue
4131    # get the strongly typed value of the node
4132    def nodeTypedValue=(arg0)
4133      ret = _setproperty(25, [arg0], [VT_VARIANT])
4134      @lastargs = WIN32OLE::ARGV
4135      ret
4136    end
4137  
4138    # VOID dataType
4139    # the data type of the node
4140    def dataType=(arg0)
4141      ret = _setproperty(26, [arg0], [VT_VARIANT])
4142      @lastargs = WIN32OLE::ARGV
4143      ret
4144    end
4145  
4146    # VOID data
4147    # the data
4148    def data=(arg0)
4149      ret = _setproperty(128, [arg0], [VT_BSTR])
4150      @lastargs = WIN32OLE::ARGV
4151      ret
4152    end
4153  
4154    # IXMLDOMNode insertBefore
4155    # insert a child node
4156    #   IXMLDOMNode arg0 --- newChild [IN]
4157    #   VARIANT arg1 --- refChild [IN]
4158    def insertBefore(arg0, arg1)
4159      ret = _invoke(13, [arg0, arg1], [VT_BYREF|VT_DISPATCH, VT_VARIANT])
4160      @lastargs = WIN32OLE::ARGV
4161      ret
4162    end
4163  
4164    # IXMLDOMNode replaceChild
4165    # replace a child node
4166    #   IXMLDOMNode arg0 --- newChild [IN]
4167    #   IXMLDOMNode arg1 --- oldChild [IN]
4168    def replaceChild(arg0, arg1)
4169      ret = _invoke(14, [arg0, arg1], [VT_BYREF|VT_DISPATCH, VT_BYREF|VT_DISPATCH])
4170      @lastargs = WIN32OLE::ARGV
4171      ret
4172    end
4173  
4174    # IXMLDOMNode removeChild
4175    # remove a child node
4176    #   IXMLDOMNode arg0 --- childNode [IN]
4177    def removeChild(arg0)
4178      ret = _invoke(15, [arg0], [VT_BYREF|VT_DISPATCH])
4179      @lastargs = WIN32OLE::ARGV
4180      ret
4181    end
4182  
4183    # IXMLDOMNode appendChild
4184    # append a child node
4185    #   IXMLDOMNode arg0 --- newChild [IN]
4186    def appendChild(arg0)
4187      ret = _invoke(16, [arg0], [VT_BYREF|VT_DISPATCH])
4188      @lastargs = WIN32OLE::ARGV
4189      ret
4190    end
4191  
4192    # BOOL hasChildNodes
4193    def hasChildNodes()
4194      ret = _invoke(17, [], [])
4195      @lastargs = WIN32OLE::ARGV
4196      ret
4197    end
4198  
4199    # IXMLDOMNode cloneNode
4200    #   BOOL arg0 --- deep [IN]
4201    def cloneNode(arg0)
4202      ret = _invoke(19, [arg0], [VT_BOOL])
4203      @lastargs = WIN32OLE::ARGV
4204      ret
4205    end
4206  
4207    # BSTR transformNode
4208    # apply the stylesheet to the subtree
4209    #   IXMLDOMNode arg0 --- stylesheet [IN]
4210    def transformNode(arg0)
4211      ret = _invoke(28, [arg0], [VT_BYREF|VT_DISPATCH])
4212      @lastargs = WIN32OLE::ARGV
4213      ret
4214    end
4215  
4216    # IXMLDOMNodeList selectNodes
4217    # execute query on the subtree
4218    #   BSTR arg0 --- queryString [IN]
4219    def selectNodes(arg0)
4220      ret = _invoke(29, [arg0], [VT_BSTR])
4221      @lastargs = WIN32OLE::ARGV
4222      ret
4223    end
4224  
4225    # IXMLDOMNode selectSingleNode
4226    # execute query on the subtree
4227    #   BSTR arg0 --- queryString [IN]
4228    def selectSingleNode(arg0)
4229      ret = _invoke(30, [arg0], [VT_BSTR])
4230      @lastargs = WIN32OLE::ARGV
4231      ret
4232    end
4233  
4234    # VOID transformNodeToObject
4235    # apply the stylesheet to the subtree, returning the result through a document or a stream
4236    #   IXMLDOMNode arg0 --- stylesheet [IN]
4237    #   VARIANT arg1 --- outputObject [IN]
4238    def transformNodeToObject(arg0, arg1)
4239      ret = _invoke(35, [arg0, arg1], [VT_BYREF|VT_DISPATCH, VT_VARIANT])
4240      @lastargs = WIN32OLE::ARGV
4241      ret
4242    end
4243  end
4244  
4245  # 
4246  module IXMLDOMEntityReference
4247    include WIN32OLE::VARIANT
4248    attr_reader :lastargs
4249  
4250    # BSTR nodeName
4251    # name of the node
4252    def nodeName()
4253      ret = _getproperty(2, [], [])
4254      @lastargs = WIN32OLE::ARGV
4255      ret
4256    end
4257  
4258    # VARIANT nodeValue
4259    # value stored in the node
4260    def nodeValue()
4261      ret = _getproperty(3, [], [])
4262      @lastargs = WIN32OLE::ARGV
4263      ret
4264    end
4265  
4266    # DOMNodeType nodeType
4267    # the node's type
4268    def nodeType()
4269      ret = _getproperty(4, [], [])
4270      @lastargs = WIN32OLE::ARGV
4271      ret
4272    end
4273  
4274    # IXMLDOMNode parentNode
4275    # parent of the node
4276    def parentNode()
4277      ret = _getproperty(6, [], [])
4278      @lastargs = WIN32OLE::ARGV
4279      ret
4280    end
4281  
4282    # IXMLDOMNodeList childNodes
4283    # the collection of the node's children
4284    def childNodes()
4285      ret = _getproperty(7, [], [])
4286      @lastargs = WIN32OLE::ARGV
4287      ret
4288    end
4289  
4290    # IXMLDOMNode firstChild
4291    # first child of the node
4292    def firstChild()
4293      ret = _getproperty(8, [], [])
4294      @lastargs = WIN32OLE::ARGV
4295      ret
4296    end
4297  
4298    # IXMLDOMNode lastChild
4299    # first child of the node
4300    def lastChild()
4301      ret = _getproperty(9, [], [])
4302      @lastargs = WIN32OLE::ARGV
4303      ret
4304    end
4305  
4306    # IXMLDOMNode previousSibling
4307    # left sibling of the node
4308    def previousSibling()
4309      ret = _getproperty(10, [], [])
4310      @lastargs = WIN32OLE::ARGV
4311      ret
4312    end
4313  
4314    # IXMLDOMNode nextSibling
4315    # right sibling of the node
4316    def nextSibling()
4317      ret = _getproperty(11, [], [])
4318      @lastargs = WIN32OLE::ARGV
4319      ret
4320    end
4321  
4322    # IXMLDOMNamedNodeMap attributes
4323    # the collection of the node's attributes
4324    def attributes()
4325      ret = _getproperty(12, [], [])
4326      @lastargs = WIN32OLE::ARGV
4327      ret
4328    end
4329  
4330    # IXMLDOMDocument ownerDocument
4331    # document that contains the node
4332    def ownerDocument()
4333      ret = _getproperty(18, [], [])
4334      @lastargs = WIN32OLE::ARGV
4335      ret
4336    end
4337  
4338    # BSTR nodeTypeString
4339    # the type of node in string form
4340    def nodeTypeString()
4341      ret = _getproperty(21, [], [])
4342      @lastargs = WIN32OLE::ARGV
4343      ret
4344    end
4345  
4346    # BSTR text
4347    # text content of the node and subtree
4348    def text()
4349      ret = _getproperty(24, [], [])
4350      @lastargs = WIN32OLE::ARGV
4351      ret
4352    end
4353  
4354    # BOOL specified
4355    # indicates whether node is a default value
4356    def specified()
4357      ret = _getproperty(22, [], [])
4358      @lastargs = WIN32OLE::ARGV
4359      ret
4360    end
4361  
4362    # IXMLDOMNode definition
4363    # pointer to the definition of the node in the DTD or schema
4364    def definition()
4365      ret = _getproperty(23, [], [])
4366      @lastargs = WIN32OLE::ARGV
4367      ret
4368    end
4369  
4370    # VARIANT nodeTypedValue
4371    # get the strongly typed value of the node
4372    def nodeTypedValue()
4373      ret = _getproperty(25, [], [])
4374      @lastargs = WIN32OLE::ARGV
4375      ret
4376    end
4377  
4378    # VARIANT dataType
4379    # the data type of the node
4380    def dataType()
4381      ret = _getproperty(26, [], [])
4382      @lastargs = WIN32OLE::ARGV
4383      ret
4384    end
4385  
4386    # BSTR xml
4387    # return the XML source for the node and each of its descendants
4388    def xml()
4389      ret = _getproperty(27, [], [])
4390      @lastargs = WIN32OLE::ARGV
4391      ret
4392    end
4393  
4394    # BOOL parsed
4395    # has sub-tree been completely parsed
4396    def parsed()
4397      ret = _getproperty(31, [], [])
4398      @lastargs = WIN32OLE::ARGV
4399      ret
4400    end
4401  
4402    # BSTR namespaceURI
4403    # the URI for the namespace applying to the node
4404    def namespaceURI()
4405      ret = _getproperty(32, [], [])
4406      @lastargs = WIN32OLE::ARGV
4407      ret
4408    end
4409  
4410    # BSTR prefix
4411    # the prefix for the namespace applying to the node
4412    def prefix()
4413      ret = _getproperty(33, [], [])
4414      @lastargs = WIN32OLE::ARGV
4415      ret
4416    end
4417  
4418    # BSTR baseName
4419    # the base name of the node (nodename with the prefix stripped off)
4420    def baseName()
4421      ret = _getproperty(34, [], [])
4422      @lastargs = WIN32OLE::ARGV
4423      ret
4424    end
4425  
4426    # VOID nodeValue
4427    # value stored in the node
4428    def nodeValue=(arg0)
4429      ret = _setproperty(3, [arg0], [VT_VARIANT])
4430      @lastargs = WIN32OLE::ARGV
4431      ret
4432    end
4433  
4434    # VOID text
4435    # text content of the node and subtree
4436    def text=(arg0)
4437      ret = _setproperty(24, [arg0], [VT_BSTR])
4438      @lastargs = WIN32OLE::ARGV
4439      ret
4440    end
4441  
4442    # VOID nodeTypedValue
4443    # get the strongly typed value of the node
4444    def nodeTypedValue=(arg0)
4445      ret = _setproperty(25, [arg0], [VT_VARIANT])
4446      @lastargs = WIN32OLE::ARGV
4447      ret
4448    end
4449  
4450    # VOID dataType
4451    # the data type of the node
4452    def dataType=(arg0)
4453      ret = _setproperty(26, [arg0], [VT_VARIANT])
4454      @lastargs = WIN32OLE::ARGV
4455      ret
4456    end
4457  
4458    # IXMLDOMNode insertBefore
4459    # insert a child node
4460    #   IXMLDOMNode arg0 --- newChild [IN]
4461    #   VARIANT arg1 --- refChild [IN]
4462    def insertBefore(arg0, arg1)
4463      ret = _invoke(13, [arg0, arg1], [VT_BYREF|VT_DISPATCH, VT_VARIANT])
4464      @lastargs = WIN32OLE::ARGV
4465      ret
4466    end
4467  
4468    # IXMLDOMNode replaceChild
4469    # replace a child node
4470    #   IXMLDOMNode arg0 --- newChild [IN]
4471    #   IXMLDOMNode arg1 --- oldChild [IN]
4472    def replaceChild(arg0, arg1)
4473      ret = _invoke(14, [arg0, arg1], [VT_BYREF|VT_DISPATCH, VT_BYREF|VT_DISPATCH])
4474      @lastargs = WIN32OLE::ARGV
4475      ret
4476    end
4477  
4478    # IXMLDOMNode removeChild
4479    # remove a child node
4480    #   IXMLDOMNode arg0 --- childNode [IN]
4481    def removeChild(arg0)
4482      ret = _invoke(15, [arg0], [VT_BYREF|VT_DISPATCH])
4483      @lastargs = WIN32OLE::ARGV
4484      ret
4485    end
4486  
4487    # IXMLDOMNode appendChild
4488    # append a child node
4489    #   IXMLDOMNode arg0 --- newChild [IN]
4490    def appendChild(arg0)
4491      ret = _invoke(16, [arg0], [VT_BYREF|VT_DISPATCH])
4492      @lastargs = WIN32OLE::ARGV
4493      ret
4494    end
4495  
4496    # BOOL hasChildNodes
4497    def hasChildNodes()
4498      ret = _invoke(17, [], [])
4499      @lastargs = WIN32OLE::ARGV
4500      ret
4501    end
4502  
4503    # IXMLDOMNode cloneNode
4504    #   BOOL arg0 --- deep [IN]
4505    def cloneNode(arg0)
4506      ret = _invoke(19, [arg0], [VT_BOOL])
4507      @lastargs = WIN32OLE::ARGV
4508      ret
4509    end
4510  
4511    # BSTR transformNode
4512    # apply the stylesheet to the subtree
4513    #   IXMLDOMNode arg0 --- stylesheet [IN]
4514    def transformNode(arg0)
4515      ret = _invoke(28, [arg0], [VT_BYREF|VT_DISPATCH])
4516      @lastargs = WIN32OLE::ARGV
4517      ret
4518    end
4519  
4520    # IXMLDOMNodeList selectNodes
4521    # execute query on the subtree
4522    #   BSTR arg0 --- queryString [IN]
4523    def selectNodes(arg0)
4524      ret = _invoke(29, [arg0], [VT_BSTR])
4525      @lastargs = WIN32OLE::ARGV
4526      ret
4527    end
4528  
4529    # IXMLDOMNode selectSingleNode
4530    # execute query on the subtree
4531    #   BSTR arg0 --- queryString [IN]
4532    def selectSingleNode(arg0)
4533      ret = _invoke(30, [arg0], [VT_BSTR])
4534      @lastargs = WIN32OLE::ARGV
4535      ret
4536    end
4537  
4538    # VOID transformNodeToObject
4539    # apply the stylesheet to the subtree, returning the result through a document or a stream
4540    #   IXMLDOMNode arg0 --- stylesheet [IN]
4541    #   VARIANT arg1 --- outputObject [IN]
4542    def transformNodeToObject(arg0, arg1)
4543      ret = _invoke(35, [arg0, arg1], [VT_BYREF|VT_DISPATCH, VT_VARIANT])
4544      @lastargs = WIN32OLE::ARGV
4545      ret
4546    end
4547  end
4548  
4549  # structure for reporting parser errors
4550  module IXMLDOMParseError
4551    include WIN32OLE::VARIANT
4552    attr_reader :lastargs
4553  
4554    # I4 errorCode
4555    # the error code
4556    def errorCode()
4557      ret = _getproperty(0, [], [])
4558      @lastargs = WIN32OLE::ARGV
4559      ret
4560    end
4561  
4562    # BSTR url
4563    # the URL of the XML document containing the error
4564    def url()
4565      ret = _getproperty(179, [], [])
4566      @lastargs = WIN32OLE::ARGV
4567      ret
4568    end
4569  
4570    # BSTR reason
4571    # the cause of the error
4572    def reason()
4573      ret = _getproperty(180, [], [])
4574      @lastargs = WIN32OLE::ARGV
4575      ret
4576    end
4577  
4578    # BSTR srcText
4579    # the data where the error occurred
4580    def srcText()
4581      ret = _getproperty(181, [], [])
4582      @lastargs = WIN32OLE::ARGV
4583      ret
4584    end
4585  
4586    # I4 line
4587    # the line number in the XML document where the error occurred
4588    def line()
4589      ret = _getproperty(182, [], [])
4590      @lastargs = WIN32OLE::ARGV
4591      ret
4592    end
4593  
4594    # I4 linepos
4595    # the character position in the line containing the error
4596    def linepos()
4597      ret = _getproperty(183, [], [])
4598      @lastargs = WIN32OLE::ARGV
4599      ret
4600    end
4601  
4602    # I4 filepos
4603    # the absolute file position in the XML document containing the error
4604    def filepos()
4605      ret = _getproperty(184, [], [])
4606      @lastargs = WIN32OLE::ARGV
4607      ret
4608    end
4609  end
4610  
4611  # 
4612  module IXMLDOMNotation
4613    include WIN32OLE::VARIANT
4614    attr_reader :lastargs
4615  
4616    # BSTR nodeName
4617    # name of the node
4618    def nodeName()
4619      ret = _getproperty(2, [], [])
4620      @lastargs = WIN32OLE::ARGV
4621      ret
4622    end
4623  
4624    # VARIANT nodeValue
4625    # value stored in the node
4626    def nodeValue()
4627      ret = _getproperty(3, [], [])
4628      @lastargs = WIN32OLE::ARGV
4629      ret
4630    end
4631  
4632    # DOMNodeType nodeType
4633    # the node's type
4634    def nodeType()
4635      ret = _getproperty(4, [], [])
4636      @lastargs = WIN32OLE::ARGV
4637      ret
4638    end
4639  
4640    # IXMLDOMNode parentNode
4641    # parent of the node
4642    def parentNode()
4643      ret = _getproperty(6, [], [])
4644      @lastargs = WIN32OLE::ARGV
4645      ret
4646    end
4647  
4648    # IXMLDOMNodeList childNodes
4649    # the collection of the node's children
4650    def childNodes()
4651      ret = _getproperty(7, [], [])
4652      @lastargs = WIN32OLE::ARGV
4653      ret
4654    end
4655  
4656    # IXMLDOMNode firstChild
4657    # first child of the node
4658    def firstChild()
4659      ret = _getproperty(8, [], [])
4660      @lastargs = WIN32OLE::ARGV
4661      ret
4662    end
4663  
4664    # IXMLDOMNode lastChild
4665    # first child of the node
4666    def lastChild()
4667      ret = _getproperty(9, [], [])
4668      @lastargs = WIN32OLE::ARGV
4669      ret
4670    end
4671  
4672    # IXMLDOMNode previousSibling
4673    # left sibling of the node
4674    def previousSibling()
4675      ret = _getproperty(10, [], [])
4676      @lastargs = WIN32OLE::ARGV
4677      ret
4678    end
4679  
4680    # IXMLDOMNode nextSibling
4681    # right sibling of the node
4682    def nextSibling()
4683      ret = _getproperty(11, [], [])
4684      @lastargs = WIN32OLE::ARGV
4685      ret
4686    end
4687  
4688    # IXMLDOMNamedNodeMap attributes
4689    # the collection of the node's attributes
4690    def attributes()
4691      ret = _getproperty(12, [], [])
4692      @lastargs = WIN32OLE::ARGV
4693      ret
4694    end
4695  
4696    # IXMLDOMDocument ownerDocument
4697    # document that contains the node
4698    def ownerDocument()
4699      ret = _getproperty(18, [], [])
4700      @lastargs = WIN32OLE::ARGV
4701      ret
4702    end
4703  
4704    # BSTR nodeTypeString
4705    # the type of node in string form
4706    def nodeTypeString()
4707      ret = _getproperty(21, [], [])
4708      @lastargs = WIN32OLE::ARGV
4709      ret
4710    end
4711  
4712    # BSTR text
4713    # text content of the node and subtree
4714    def text()
4715      ret = _getproperty(24, [], [])
4716      @lastargs = WIN32OLE::ARGV
4717      ret
4718    end
4719  
4720    # BOOL specified
4721    # indicates whether node is a default value
4722    def specified()
4723      ret = _getproperty(22, [], [])
4724      @lastargs = WIN32OLE::ARGV
4725      ret
4726    end
4727  
4728    # IXMLDOMNode definition
4729    # pointer to the definition of the node in the DTD or schema
4730    def definition()
4731      ret = _getproperty(23, [], [])
4732      @lastargs = WIN32OLE::ARGV
4733      ret
4734    end
4735  
4736    # VARIANT nodeTypedValue
4737    # get the strongly typed value of the node
4738    def nodeTypedValue()
4739      ret = _getproperty(25, [], [])
4740      @lastargs = WIN32OLE::ARGV
4741      ret
4742    end
4743  
4744    # VARIANT dataType
4745    # the data type of the node
4746    def dataType()
4747      ret = _getproperty(26, [], [])
4748      @lastargs = WIN32OLE::ARGV
4749      ret
4750    end
4751  
4752    # BSTR xml
4753    # return the XML source for the node and each of its descendants
4754    def xml()
4755      ret = _getproperty(27, [], [])
4756      @lastargs = WIN32OLE::ARGV
4757      ret
4758    end
4759  
4760    # BOOL parsed
4761    # has sub-tree been completely parsed
4762    def parsed()
4763      ret = _getproperty(31, [], [])
4764      @lastargs = WIN32OLE::ARGV
4765      ret
4766    end
4767  
4768    # BSTR namespaceURI
4769    # the URI for the namespace applying to the node
4770    def namespaceURI()
4771      ret = _getproperty(32, [], [])
4772      @lastargs = WIN32OLE::ARGV
4773      ret
4774    end
4775  
4776    # BSTR prefix
4777    # the prefix for the namespace applying to the node
4778    def prefix()
4779      ret = _getproperty(33, [], [])
4780      @lastargs = WIN32OLE::ARGV
4781      ret
4782    end
4783  
4784    # BSTR baseName
4785    # the base name of the node (nodename with the prefix stripped off)
4786    def baseName()
4787      ret = _getproperty(34, [], [])
4788      @lastargs = WIN32OLE::ARGV
4789      ret
4790    end
4791  
4792    # VARIANT publicId
4793    # the public ID
4794    def publicId()
4795      ret = _getproperty(136, [], [])
4796      @lastargs = WIN32OLE::ARGV
4797      ret
4798    end
4799  
4800    # VARIANT systemId
4801    # the system ID
4802    def systemId()
4803      ret = _getproperty(137, [], [])
4804      @lastargs = WIN32OLE::ARGV
4805      ret
4806    end
4807  
4808    # VOID nodeValue
4809    # value stored in the node
4810    def nodeValue=(arg0)
4811      ret = _setproperty(3, [arg0], [VT_VARIANT])
4812      @lastargs = WIN32OLE::ARGV
4813      ret
4814    end
4815  
4816    # VOID text
4817    # text content of the node and subtree
4818    def text=(arg0)
4819      ret = _setproperty(24, [arg0], [VT_BSTR])
4820      @lastargs = WIN32OLE::ARGV
4821      ret
4822    end
4823  
4824    # VOID nodeTypedValue
4825    # get the strongly typed value of the node
4826    def nodeTypedValue=(arg0)
4827      ret = _setproperty(25, [arg0], [VT_VARIANT])
4828      @lastargs = WIN32OLE::ARGV
4829      ret
4830    end
4831  
4832    # VOID dataType
4833    # the data type of the node
4834    def dataType=(arg0)
4835      ret = _setproperty(26, [arg0], [VT_VARIANT])
4836      @lastargs = WIN32OLE::ARGV
4837      ret
4838    end
4839  
4840    # IXMLDOMNode insertBefore
4841    # insert a child node
4842    #   IXMLDOMNode arg0 --- newChild [IN]
4843    #   VARIANT arg1 --- refChild [IN]
4844    def insertBefore(arg0, arg1)
4845      ret = _invoke(13, [arg0, arg1], [VT_BYREF|VT_DISPATCH, VT_VARIANT])
4846      @lastargs = WIN32OLE::ARGV
4847      ret
4848    end
4849  
4850    # IXMLDOMNode replaceChild
4851    # replace a child node
4852    #   IXMLDOMNode arg0 --- newChild [IN]
4853    #   IXMLDOMNode arg1 --- oldChild [IN]
4854    def replaceChild(arg0, arg1)
4855      ret = _invoke(14, [arg0, arg1], [VT_BYREF|VT_DISPATCH, VT_BYREF|VT_DISPATCH])
4856      @lastargs = WIN32OLE::ARGV
4857      ret
4858    end
4859  
4860    # IXMLDOMNode removeChild
4861    # remove a child node
4862    #   IXMLDOMNode arg0 --- childNode [IN]
4863    def removeChild(arg0)
4864      ret = _invoke(15, [arg0], [VT_BYREF|VT_DISPATCH])
4865      @lastargs = WIN32OLE::ARGV
4866      ret
4867    end
4868  
4869    # IXMLDOMNode appendChild
4870    # append a child node
4871    #   IXMLDOMNode arg0 --- newChild [IN]
4872    def appendChild(arg0)
4873      ret = _invoke(16, [arg0], [VT_BYREF|VT_DISPATCH])
4874      @lastargs = WIN32OLE::ARGV
4875      ret
4876    end
4877  
4878    # BOOL hasChildNodes
4879    def hasChildNodes()
4880      ret = _invoke(17, [], [])
4881      @lastargs = WIN32OLE::ARGV
4882      ret
4883    end
4884  
4885    # IXMLDOMNode cloneNode
4886    #   BOOL arg0 --- deep [IN]
4887    def cloneNode(arg0)
4888      ret = _invoke(19, [arg0], [VT_BOOL])
4889      @lastargs = WIN32OLE::ARGV
4890      ret
4891    end
4892  
4893    # BSTR transformNode
4894    # apply the stylesheet to the subtree
4895    #   IXMLDOMNode arg0 --- stylesheet [IN]
4896    def transformNode(arg0)
4897      ret = _invoke(28, [arg0], [VT_BYREF|VT_DISPATCH])
4898      @lastargs = WIN32OLE::ARGV
4899      ret
4900    end
4901  
4902    # IXMLDOMNodeList selectNodes
4903    # execute query on the subtree
4904    #   BSTR arg0 --- queryString [IN]
4905    def selectNodes(arg0)
4906      ret = _invoke(29, [arg0], [VT_BSTR])
4907      @lastargs = WIN32OLE::ARGV
4908      ret
4909    end
4910  
4911    # IXMLDOMNode selectSingleNode
4912    # execute query on the subtree
4913    #   BSTR arg0 --- queryString [IN]
4914    def selectSingleNode(arg0)
4915      ret = _invoke(30, [arg0], [VT_BSTR])
4916      @lastargs = WIN32OLE::ARGV
4917      ret
4918    end
4919  
4920    # VOID transformNodeToObject
4921    # apply the stylesheet to the subtree, returning the result through a document or a stream
4922    #   IXMLDOMNode arg0 --- stylesheet [IN]
4923    #   VARIANT arg1 --- outputObject [IN]
4924    def transformNodeToObject(arg0, arg1)
4925      ret = _invoke(35, [arg0, arg1], [VT_BYREF|VT_DISPATCH, VT_VARIANT])
4926      @lastargs = WIN32OLE::ARGV
4927      ret
4928    end
4929  end
4930  
4931  # 
4932  module IXMLDOMEntity
4933    include WIN32OLE::VARIANT
4934    attr_reader :lastargs
4935  
4936    # BSTR nodeName
4937    # name of the node
4938    def nodeName()
4939      ret = _getproperty(2, [], [])
4940      @lastargs = WIN32OLE::ARGV
4941      ret
4942    end
4943  
4944    # VARIANT nodeValue
4945    # value stored in the node
4946    def nodeValue()
4947      ret = _getproperty(3, [], [])
4948      @lastargs = WIN32OLE::ARGV
4949      ret
4950    end
4951  
4952    # DOMNodeType nodeType
4953    # the node's type
4954    def nodeType()
4955      ret = _getproperty(4, [], [])
4956      @lastargs = WIN32OLE::ARGV
4957      ret
4958    end
4959  
4960    # IXMLDOMNode parentNode
4961    # parent of the node
4962    def parentNode()
4963      ret = _getproperty(6, [], [])
4964      @lastargs = WIN32OLE::ARGV
4965      ret
4966    end
4967  
4968    # IXMLDOMNodeList childNodes
4969    # the collection of the node's children
4970    def childNodes()
4971      ret = _getproperty(7, [], [])
4972      @lastargs = WIN32OLE::ARGV
4973      ret
4974    end
4975  
4976    # IXMLDOMNode firstChild
4977    # first child of the node
4978    def firstChild()
4979      ret = _getproperty(8, [], [])
4980      @lastargs = WIN32OLE::ARGV
4981      ret
4982    end
4983  
4984    # IXMLDOMNode lastChild
4985    # first child of the node
4986    def lastChild()
4987      ret = _getproperty(9, [], [])
4988      @lastargs = WIN32OLE::ARGV
4989      ret
4990    end
4991  
4992    # IXMLDOMNode previousSibling
4993    # left sibling of the node
4994    def previousSibling()
4995      ret = _getproperty(10, [], [])
4996      @lastargs = WIN32OLE::ARGV
4997      ret
4998    end
4999  
5000    # IXMLDOMNode nextSibling
5001    # right sibling of the node
5002    def nextSibling()
5003      ret = _getproperty(11, [], [])
5004      @lastargs = WIN32OLE::ARGV
5005      ret
5006    end
5007  
5008    # IXMLDOMNamedNodeMap attributes
5009    # the collection of the node's attributes
5010    def attributes()
5011      ret = _getproperty(12, [], [])
5012      @lastargs = WIN32OLE::ARGV
5013      ret
5014    end
5015  
5016    # IXMLDOMDocument ownerDocument
5017    # document that contains the node
5018    def ownerDocument()
5019      ret = _getproperty(18, [], [])
5020      @lastargs = WIN32OLE::ARGV
5021      ret
5022    end
5023  
5024    # BSTR nodeTypeString
5025    # the type of node in string form
5026    def nodeTypeString()
5027      ret = _getproperty(21, [], [])
5028      @lastargs = WIN32OLE::ARGV
5029      ret
5030    end
5031  
5032    # BSTR text
5033    # text content of the node and subtree
5034    def text()
5035      ret = _getproperty(24, [], [])
5036      @lastargs = WIN32OLE::ARGV
5037      ret
5038    end
5039  
5040    # BOOL specified
5041    # indicates whether node is a default value
5042    def specified()
5043      ret = _getproperty(22, [], [])
5044      @lastargs = WIN32OLE::ARGV
5045      ret
5046    end
5047  
5048    # IXMLDOMNode definition
5049    # pointer to the definition of the node in the DTD or schema
5050    def definition()
5051      ret = _getproperty(23, [], [])
5052      @lastargs = WIN32OLE::ARGV
5053      ret
5054    end
5055  
5056    # VARIANT nodeTypedValue
5057    # get the strongly typed value of the node
5058    def nodeTypedValue()
5059      ret = _getproperty(25, [], [])
5060      @lastargs = WIN32OLE::ARGV
5061      ret
5062    end
5063  
5064    # VARIANT dataType
5065    # the data type of the node
5066    def dataType()
5067      ret = _getproperty(26, [], [])
5068      @lastargs = WIN32OLE::ARGV
5069      ret
5070    end
5071  
5072    # BSTR xml
5073    # return the XML source for the node and each of its descendants
5074    def xml()
5075      ret = _getproperty(27, [], [])
5076      @lastargs = WIN32OLE::ARGV
5077      ret
5078    end
5079  
5080    # BOOL parsed
5081    # has sub-tree been completely parsed
5082    def parsed()
5083      ret = _getproperty(31, [], [])
5084      @lastargs = WIN32OLE::ARGV
5085      ret
5086    end
5087  
5088    # BSTR namespaceURI
5089    # the URI for the namespace applying to the node
5090    def namespaceURI()
5091      ret = _getproperty(32, [], [])
5092      @lastargs = WIN32OLE::ARGV
5093      ret
5094    end
5095  
5096    # BSTR prefix
5097    # the prefix for the namespace applying to the node
5098    def prefix()
5099      ret = _getproperty(33, [], [])
5100      @lastargs = WIN32OLE::ARGV
5101      ret
5102    end
5103  
5104    # BSTR baseName
5105    # the base name of the node (nodename with the prefix stripped off)
5106    def baseName()
5107      ret = _getproperty(34, [], [])
5108      @lastargs = WIN32OLE::ARGV
5109      ret
5110    end
5111  
5112    # VARIANT publicId
5113    # the public ID
5114    def publicId()
5115      ret = _getproperty(140, [], [])
5116      @lastargs = WIN32OLE::ARGV
5117      ret
5118    end
5119  
5120    # VARIANT systemId
5121    # the system ID
5122    def systemId()
5123      ret = _getproperty(141, [], [])
5124      @lastargs = WIN32OLE::ARGV
5125      ret
5126    end
5127  
5128    # BSTR notationName
5129    # the name of the notation
5130    def notationName()
5131      ret = _getproperty(142, [], [])
5132      @lastargs = WIN32OLE::ARGV
5133      ret
5134    end
5135  
5136    # VOID nodeValue
5137    # value stored in the node
5138    def nodeValue=(arg0)
5139      ret = _setproperty(3, [arg0], [VT_VARIANT])
5140      @lastargs = WIN32OLE::ARGV
5141      ret
5142    end
5143  
5144    # VOID text
5145    # text content of the node and subtree
5146    def text=(arg0)
5147      ret = _setproperty(24, [arg0], [VT_BSTR])
5148      @lastargs = WIN32OLE::ARGV
5149      ret
5150    end
5151  
5152    # VOID nodeTypedValue
5153    # get the strongly typed value of the node
5154    def nodeTypedValue=(arg0)
5155      ret = _setproperty(25, [arg0], [VT_VARIANT])
5156      @lastargs = WIN32OLE::ARGV
5157      ret
5158    end
5159  
5160    # VOID dataType
5161    # the data type of the node
5162    def dataType=(arg0)
5163      ret = _setproperty(26, [arg0], [VT_VARIANT])
5164      @lastargs = WIN32OLE::ARGV
5165      ret
5166    end
5167  
5168    # IXMLDOMNode insertBefore
5169    # insert a child node
5170    #   IXMLDOMNode arg0 --- newChild [IN]
5171    #   VARIANT arg1 --- refChild [IN]
5172    def insertBefore(arg0, arg1)
5173      ret = _invoke(13, [arg0, arg1], [VT_BYREF|VT_DISPATCH, VT_VARIANT])
5174      @lastargs = WIN32OLE::ARGV
5175      ret
5176    end
5177  
5178    # IXMLDOMNode replaceChild
5179    # replace a child node
5180    #   IXMLDOMNode arg0 --- newChild [IN]
5181    #   IXMLDOMNode arg1 --- oldChild [IN]
5182    def replaceChild(arg0, arg1)
5183      ret = _invoke(14, [arg0, arg1], [VT_BYREF|VT_DISPATCH, VT_BYREF|VT_DISPATCH])
5184      @lastargs = WIN32OLE::ARGV
5185      ret
5186    end
5187  
5188    # IXMLDOMNode removeChild
5189    # remove a child node
5190    #   IXMLDOMNode arg0 --- childNode [IN]
5191    def removeChild(arg0)
5192      ret = _invoke(15, [arg0], [VT_BYREF|VT_DISPATCH])
5193      @lastargs = WIN32OLE::ARGV
5194      ret
5195    end
5196  
5197    # IXMLDOMNode appendChild
5198    # append a child node
5199    #   IXMLDOMNode arg0 --- newChild [IN]
5200    def appendChild(arg0)
5201      ret = _invoke(16, [arg0], [VT_BYREF|VT_DISPATCH])
5202      @lastargs = WIN32OLE::ARGV
5203      ret
5204    end
5205  
5206    # BOOL hasChildNodes
5207    def hasChildNodes()
5208      ret = _invoke(17, [], [])
5209      @lastargs = WIN32OLE::ARGV
5210      ret
5211    end
5212  
5213    # IXMLDOMNode cloneNode
5214    #   BOOL arg0 --- deep [IN]
5215    def cloneNode(arg0)
5216      ret = _invoke(19, [arg0], [VT_BOOL])
5217      @lastargs = WIN32OLE::ARGV
5218      ret
5219    end
5220  
5221    # BSTR transformNode
5222    # apply the stylesheet to the subtree
5223    #   IXMLDOMNode arg0 --- stylesheet [IN]
5224    def transformNode(arg0)
5225      ret = _invoke(28, [arg0], [VT_BYREF|VT_DISPATCH])
5226      @lastargs = WIN32OLE::ARGV
5227      ret
5228    end
5229  
5230    # IXMLDOMNodeList selectNodes
5231    # execute query on the subtree
5232    #   BSTR arg0 --- queryString [IN]
5233    def selectNodes(arg0)
5234      ret = _invoke(29, [arg0], [VT_BSTR])
5235      @lastargs = WIN32OLE::ARGV
5236      ret
5237    end
5238  
5239    # IXMLDOMNode selectSingleNode
5240    # execute query on the subtree
5241    #   BSTR arg0 --- queryString [IN]
5242    def selectSingleNode(arg0)
5243      ret = _invoke(30, [arg0], [VT_BSTR])
5244      @lastargs = WIN32OLE::ARGV
5245      ret
5246    end
5247  
5248    # VOID transformNodeToObject
5249    # apply the stylesheet to the subtree, returning the result through a document or a stream
5250    #   IXMLDOMNode arg0 --- stylesheet [IN]
5251    #   VARIANT arg1 --- outputObject [IN]
5252    def transformNodeToObject(arg0, arg1)
5253      ret = _invoke(35, [arg0, arg1], [VT_BYREF|VT_DISPATCH, VT_VARIANT])
5254      @lastargs = WIN32OLE::ARGV
5255      ret
5256    end
5257  end
5258  
5259  # XTL runtime object
5260  module IXTLRuntime
5261    include WIN32OLE::VARIANT
5262    attr_reader :lastargs
5263  
5264    # BSTR nodeName
5265    # name of the node
5266    def nodeName()
5267      ret = _getproperty(2, [], [])
5268      @lastargs = WIN32OLE::ARGV
5269      ret
5270    end
5271  
5272    # VARIANT nodeValue
5273    # value stored in the node
5274    def nodeValue()
5275      ret = _getproperty(3, [], [])
5276      @lastargs = WIN32OLE::ARGV
5277      ret
5278    end
5279  
5280    # DOMNodeType nodeType
5281    # the node's type
5282    def nodeType()
5283      ret = _getproperty(4, [], [])
5284      @lastargs = WIN32OLE::ARGV
5285      ret
5286    end
5287  
5288    # IXMLDOMNode parentNode
5289    # parent of the node
5290    def parentNode()
5291      ret = _getproperty(6, [], [])
5292      @lastargs = WIN32OLE::ARGV
5293      ret
5294    end
5295  
5296    # IXMLDOMNodeList childNodes
5297    # the collection of the node's children
5298    def childNodes()
5299      ret = _getproperty(7, [], [])
5300      @lastargs = WIN32OLE::ARGV
5301      ret
5302    end
5303  
5304    # IXMLDOMNode firstChild
5305    # first child of the node
5306    def firstChild()
5307      ret = _getproperty(8, [], [])
5308      @lastargs = WIN32OLE::ARGV
5309      ret
5310    end
5311  
5312    # IXMLDOMNode lastChild
5313    # first child of the node
5314    def lastChild()
5315      ret = _getproperty(9, [], [])
5316      @lastargs = WIN32OLE::ARGV
5317      ret
5318    end
5319  
5320    # IXMLDOMNode previousSibling
5321    # left sibling of the node
5322    def previousSibling()
5323      ret = _getproperty(10, [], [])
5324      @lastargs = WIN32OLE::ARGV
5325      ret
5326    end
5327  
5328    # IXMLDOMNode nextSibling
5329    # right sibling of the node
5330    def nextSibling()
5331      ret = _getproperty(11, [], [])
5332      @lastargs = WIN32OLE::ARGV
5333      ret
5334    end
5335  
5336    # IXMLDOMNamedNodeMap attributes
5337    # the collection of the node's attributes
5338    def attributes()
5339      ret = _getproperty(12, [], [])
5340      @lastargs = WIN32OLE::ARGV
5341      ret
5342    end
5343  
5344    # IXMLDOMDocument ownerDocument
5345    # document that contains the node
5346    def ownerDocument()
5347      ret = _getproperty(18, [], [])
5348      @lastargs = WIN32OLE::ARGV
5349      ret
5350    end
5351  
5352    # BSTR nodeTypeString
5353    # the type of node in string form
5354    def nodeTypeString()
5355      ret = _getproperty(21, [], [])
5356      @lastargs = WIN32OLE::ARGV
5357      ret
5358    end
5359  
5360    # BSTR text
5361    # text content of the node and subtree
5362    def text()
5363      ret = _getproperty(24, [], [])
5364      @lastargs = WIN32OLE::ARGV
5365      ret
5366    end
5367  
5368    # BOOL specified
5369    # indicates whether node is a default value
5370    def specified()
5371      ret = _getproperty(22, [], [])
5372      @lastargs = WIN32OLE::ARGV
5373      ret
5374    end
5375  
5376    # IXMLDOMNode definition
5377    # pointer to the definition of the node in the DTD or schema
5378    def definition()
5379      ret = _getproperty(23, [], [])
5380      @lastargs = WIN32OLE::ARGV
5381      ret
5382    end
5383  
5384    # VARIANT nodeTypedValue
5385    # get the strongly typed value of the node
5386    def nodeTypedValue()
5387      ret = _getproperty(25, [], [])
5388      @lastargs = WIN32OLE::ARGV
5389      ret
5390    end
5391  
5392    # VARIANT dataType
5393    # the data type of the node
5394    def dataType()
5395      ret = _getproperty(26, [], [])
5396      @lastargs = WIN32OLE::ARGV
5397      ret
5398    end
5399  
5400    # BSTR xml
5401    # return the XML source for the node and each of its descendants
5402    def xml()
5403      ret = _getproperty(27, [], [])
5404      @lastargs = WIN32OLE::ARGV
5405      ret
5406    end
5407  
5408    # BOOL parsed
5409    # has sub-tree been completely parsed
5410    def parsed()
5411      ret = _getproperty(31, [], [])
5412      @lastargs = WIN32OLE::ARGV
5413      ret
5414    end
5415  
5416    # BSTR namespaceURI
5417    # the URI for the namespace applying to the node
5418    def namespaceURI()
5419      ret = _getproperty(32, [], [])
5420      @lastargs = WIN32OLE::ARGV
5421      ret
5422    end
5423  
5424    # BSTR prefix
5425    # the prefix for the namespace applying to the node
5426    def prefix()
5427      ret = _getproperty(33, [], [])
5428      @lastargs = WIN32OLE::ARGV
5429      ret
5430    end
5431  
5432    # BSTR baseName
5433    # the base name of the node (nodename with the prefix stripped off)
5434    def baseName()
5435      ret = _getproperty(34, [], [])
5436      @lastargs = WIN32OLE::ARGV
5437      ret
5438    end
5439  
5440    # VOID nodeValue
5441    # value stored in the node
5442    def nodeValue=(arg0)
5443      ret = _setproperty(3, [arg0], [VT_VARIANT])
5444      @lastargs = WIN32OLE::ARGV
5445      ret
5446    end
5447  
5448    # VOID text
5449    # text content of the node and subtree
5450    def text=(arg0)
5451      ret = _setproperty(24, [arg0], [VT_BSTR])
5452      @lastargs = WIN32OLE::ARGV
5453      ret
5454    end
5455  
5456    # VOID nodeTypedValue
5457    # get the strongly typed value of the node
5458    def nodeTypedValue=(arg0)
5459      ret = _setproperty(25, [arg0], [VT_VARIANT])
5460      @lastargs = WIN32OLE::ARGV
5461      ret
5462    end
5463  
5464    # VOID dataType
5465    # the data type of the node
5466    def dataType=(arg0)
5467      ret = _setproperty(26, [arg0], [VT_VARIANT])
5468      @lastargs = WIN32OLE::ARGV
5469      ret
5470    end
5471  
5472    # IXMLDOMNode insertBefore
5473    # insert a child node
5474    #   IXMLDOMNode arg0 --- newChild [IN]
5475    #   VARIANT arg1 --- refChild [IN]
5476    def insertBefore(arg0, arg1)
5477      ret = _invoke(13, [arg0, arg1], [VT_BYREF|VT_DISPATCH, VT_VARIANT])
5478      @lastargs = WIN32OLE::ARGV
5479      ret
5480    end
5481  
5482    # IXMLDOMNode replaceChild
5483    # replace a child node
5484    #   IXMLDOMNode arg0 --- newChild [IN]
5485    #   IXMLDOMNode arg1 --- oldChild [IN]
5486    def replaceChild(arg0, arg1)
5487      ret = _invoke(14, [arg0, arg1], [VT_BYREF|VT_DISPATCH, VT_BYREF|VT_DISPATCH])
5488      @lastargs = WIN32OLE::ARGV
5489      ret
5490    end
5491  
5492    # IXMLDOMNode removeChild
5493    # remove a child node
5494    #   IXMLDOMNode arg0 --- childNode [IN]
5495    def removeChild(arg0)
5496      ret = _invoke(15, [arg0], [VT_BYREF|VT_DISPATCH])
5497      @lastargs = WIN32OLE::ARGV
5498      ret
5499    end
5500  
5501    # IXMLDOMNode appendChild
5502    # append a child node
5503    #   IXMLDOMNode arg0 --- newChild [IN]
5504    def appendChild(arg0)
5505      ret = _invoke(16, [arg0], [VT_BYREF|VT_DISPATCH])
5506      @lastargs = WIN32OLE::ARGV
5507      ret
5508    end
5509  
5510    # BOOL hasChildNodes
5511    def hasChildNodes()
5512      ret = _invoke(17, [], [])
5513      @lastargs = WIN32OLE::ARGV
5514      ret
5515    end
5516  
5517    # IXMLDOMNode cloneNode
5518    #   BOOL arg0 --- deep [IN]
5519    def cloneNode(arg0)
5520      ret = _invoke(19, [arg0], [VT_BOOL])
5521      @lastargs = WIN32OLE::ARGV
5522      ret
5523    end
5524  
5525    # BSTR transformNode
5526    # apply the stylesheet to the subtree
5527    #   IXMLDOMNode arg0 --- stylesheet [IN]
5528    def transformNode(arg0)
5529      ret = _invoke(28, [arg0], [VT_BYREF|VT_DISPATCH])
5530      @lastargs = WIN32OLE::ARGV
5531      ret
5532    end
5533  
5534    # IXMLDOMNodeList selectNodes
5535    # execute query on the subtree
5536    #   BSTR arg0 --- queryString [IN]
5537    def selectNodes(arg0)
5538      ret = _invoke(29, [arg0], [VT_BSTR])
5539      @lastargs = WIN32OLE::ARGV
5540      ret
5541    end
5542  
5543    # IXMLDOMNode selectSingleNode
5544    # execute query on the subtree
5545    #   BSTR arg0 --- queryString [IN]
5546    def selectSingleNode(arg0)
5547      ret = _invoke(30, [arg0], [VT_BSTR])
5548      @lastargs = WIN32OLE::ARGV
5549      ret
5550    end
5551  
5552    # VOID transformNodeToObject
5553    # apply the stylesheet to the subtree, returning the result through a document or a stream
5554    #   IXMLDOMNode arg0 --- stylesheet [IN]
5555    #   VARIANT arg1 --- outputObject [IN]
5556    def transformNodeToObject(arg0, arg1)
5557      ret = _invoke(35, [arg0, arg1], [VT_BYREF|VT_DISPATCH, VT_VARIANT])
5558      @lastargs = WIN32OLE::ARGV
5559      ret
5560    end
5561  
5562    # I4 uniqueID
5563    #   IXMLDOMNode arg0 --- pNode [IN]
5564    def uniqueID(arg0)
5565      ret = _invoke(187, [arg0], [VT_BYREF|VT_DISPATCH])
5566      @lastargs = WIN32OLE::ARGV
5567      ret
5568    end
5569  
5570    # I4 depth
5571    #   IXMLDOMNode arg0 --- pNode [IN]
5572    def depth(arg0)
5573      ret = _invoke(188, [arg0], [VT_BYREF|VT_DISPATCH])
5574      @lastargs = WIN32OLE::ARGV
5575      ret
5576    end
5577  
5578    # I4 childNumber
5579    #   IXMLDOMNode arg0 --- pNode [IN]
5580    def childNumber(arg0)
5581      ret = _invoke(189, [arg0], [VT_BYREF|VT_DISPATCH])
5582      @lastargs = WIN32OLE::ARGV
5583      ret
5584    end
5585  
5586    # I4 ancestorChildNumber
5587    #   BSTR arg0 --- bstrNodeName [IN]
5588    #   IXMLDOMNode arg1 --- pNode [IN]
5589    def ancestorChildNumber(arg0, arg1)
5590      ret = _invoke(190, [arg0, arg1], [VT_BSTR, VT_BYREF|VT_DISPATCH])
5591      @lastargs = WIN32OLE::ARGV
5592      ret
5593    end
5594  
5595    # I4 absoluteChildNumber
5596    #   IXMLDOMNode arg0 --- pNode [IN]
5597    def absoluteChildNumber(arg0)
5598      ret = _invoke(191, [arg0], [VT_BYREF|VT_DISPATCH])
5599      @lastargs = WIN32OLE::ARGV
5600      ret
5601    end
5602  
5603    # BSTR formatIndex
5604    #   I4 arg0 --- lIndex [IN]
5605    #   BSTR arg1 --- bstrFormat [IN]
5606    def formatIndex(arg0, arg1)
5607      ret = _invoke(192, [arg0, arg1], [VT_I4, VT_BSTR])
5608      @lastargs = WIN32OLE::ARGV
5609      ret
5610    end
5611  
5612    # BSTR formatNumber
5613    #   R8 arg0 --- dblNumber [IN]
5614    #   BSTR arg1 --- bstrFormat [IN]
5615    def formatNumber(arg0, arg1)
5616      ret = _invoke(193, [arg0, arg1], [VT_R8, VT_BSTR])
5617      @lastargs = WIN32OLE::ARGV
5618      ret
5619    end
5620  
5621    # BSTR formatDate
5622    #   VARIANT arg0 --- varDate [IN]
5623    #   BSTR arg1 --- bstrFormat [IN]
5624    #   VARIANT arg2 --- varDestLocale [IN]
5625    def formatDate(arg0, arg1, arg2=nil)
5626      ret = _invoke(194, [arg0, arg1, arg2], [VT_VARIANT, VT_BSTR, VT_VARIANT])
5627      @lastargs = WIN32OLE::ARGV
5628      ret
5629    end
5630  
5631    # BSTR formatTime
5632    #   VARIANT arg0 --- varTime [IN]
5633    #   BSTR arg1 --- bstrFormat [IN]
5634    #   VARIANT arg2 --- varDestLocale [IN]
5635    def formatTime(arg0, arg1, arg2=nil)
5636      ret = _invoke(195, [arg0, arg1, arg2], [VT_VARIANT, VT_BSTR, VT_VARIANT])
5637      @lastargs = WIN32OLE::ARGV
5638      ret
5639    end
5640  end
5641  
5642  # W3C-DOM XML Document
5643  class Microsoft_XMLDOM_1_0 # DOMDocument
5644    include WIN32OLE::VARIANT
5645    attr_reader :lastargs
5646    attr_reader :dispatch
5647    attr_reader :clsid
5648    attr_reader :progid
5649  
5650    def initialize(obj = nil)
5651      @clsid = "{2933BF90-7B36-11D2-B20E-00C04F983E60}"
5652      @progid = "Microsoft.XMLDOM.1.0"
5653      if obj.nil?
5654        @dispatch = WIN32OLE.new @progid
5655      else
5656        @dispatch = obj
5657      end
5658    end
5659  
5660    def method_missing(cmd, *arg)
5661      @dispatch.method_missing(cmd, *arg)
5662    end
5663  
5664    # BSTR nodeName
5665    # name of the node
5666    def nodeName()
5667      ret = @dispatch._getproperty(2, [], [])
5668      @lastargs = WIN32OLE::ARGV
5669      ret
5670    end
5671  
5672    # VARIANT nodeValue
5673    # value stored in the node
5674    def nodeValue()
5675      ret = @dispatch._getproperty(3, [], [])
5676      @lastargs = WIN32OLE::ARGV
5677      ret
5678    end
5679  
5680    # DOMNodeType nodeType
5681    # the node's type
5682    def nodeType()
5683      ret = @dispatch._getproperty(4, [], [])
5684      @lastargs = WIN32OLE::ARGV
5685      ret
5686    end
5687  
5688    # IXMLDOMNode parentNode
5689    # parent of the node
5690    def parentNode()
5691      ret = @dispatch._getproperty(6, [], [])
5692      @lastargs = WIN32OLE::ARGV
5693      ret
5694    end
5695  
5696    # IXMLDOMNodeList childNodes
5697    # the collection of the node's children
5698    def childNodes()
5699      ret = @dispatch._getproperty(7, [], [])
5700      @lastargs = WIN32OLE::ARGV
5701      ret
5702    end
5703  
5704    # IXMLDOMNode firstChild
5705    # first child of the node
5706    def firstChild()
5707      ret = @dispatch._getproperty(8, [], [])
5708      @lastargs = WIN32OLE::ARGV
5709      ret
5710    end
5711  
5712    # IXMLDOMNode lastChild
5713    # first child of the node
5714    def lastChild()
5715      ret = @dispatch._getproperty(9, [], [])
5716      @lastargs = WIN32OLE::ARGV
5717      ret
5718    end
5719  
5720    # IXMLDOMNode previousSibling
5721    # left sibling of the node
5722    def previousSibling()
5723      ret = @dispatch._getproperty(10, [], [])
5724      @lastargs = WIN32OLE::ARGV
5725      ret
5726    end
5727  
5728    # IXMLDOMNode nextSibling
5729    # right sibling of the node
5730    def nextSibling()
5731      ret = @dispatch._getproperty(11, [], [])
5732      @lastargs = WIN32OLE::ARGV
5733      ret
5734    end
5735  
5736    # IXMLDOMNamedNodeMap attributes
5737    # the collection of the node's attributes
5738    def attributes()
5739      ret = @dispatch._getproperty(12, [], [])
5740      @lastargs = WIN32OLE::ARGV
5741      ret
5742    end
5743  
5744    # IXMLDOMDocument ownerDocument
5745    # document that contains the node
5746    def ownerDocument()
5747      ret = @dispatch._getproperty(18, [], [])
5748      @lastargs = WIN32OLE::ARGV
5749      ret
5750    end
5751  
5752    # BSTR nodeTypeString
5753    # the type of node in string form
5754    def nodeTypeString()
5755      ret = @dispatch._getproperty(21, [], [])
5756      @lastargs = WIN32OLE::ARGV
5757      ret
5758    end
5759  
5760    # BSTR text
5761    # text content of the node and subtree
5762    def text()
5763      ret = @dispatch._getproperty(24, [], [])
5764      @lastargs = WIN32OLE::ARGV
5765      ret
5766    end
5767  
5768    # BOOL specified
5769    # indicates whether node is a default value
5770    def specified()
5771      ret = @dispatch._getproperty(22, [], [])
5772      @lastargs = WIN32OLE::ARGV
5773      ret
5774    end
5775  
5776    # IXMLDOMNode definition
5777    # pointer to the definition of the node in the DTD or schema
5778    def definition()
5779      ret = @dispatch._getproperty(23, [], [])
5780      @lastargs = WIN32OLE::ARGV
5781      ret
5782    end
5783  
5784    # VARIANT nodeTypedValue
5785    # get the strongly typed value of the node
5786    def nodeTypedValue()
5787      ret = @dispatch._getproperty(25, [], [])
5788      @lastargs = WIN32OLE::ARGV
5789      ret
5790    end
5791  
5792    # VARIANT dataType
5793    # the data type of the node
5794    def dataType()
5795      ret = @dispatch._getproperty(26, [], [])
5796      @lastargs = WIN32OLE::ARGV
5797      ret
5798    end
5799  
5800    # BSTR xml
5801    # return the XML source for the node and each of its descendants
5802    def xml()
5803      ret = @dispatch._getproperty(27, [], [])
5804      @lastargs = WIN32OLE::ARGV
5805      ret
5806    end
5807  
5808    # BOOL parsed
5809    # has sub-tree been completely parsed
5810    def parsed()
5811      ret = @dispatch._getproperty(31, [], [])
5812      @lastargs = WIN32OLE::ARGV
5813      ret
5814    end
5815  
5816    # BSTR namespaceURI
5817    # the URI for the namespace applying to the node
5818    def namespaceURI()
5819      ret = @dispatch._getproperty(32, [], [])
5820      @lastargs = WIN32OLE::ARGV
5821      ret
5822    end
5823  
5824    # BSTR prefix
5825    # the prefix for the namespace applying to the node
5826    def prefix()
5827      ret = @dispatch._getproperty(33, [], [])
5828      @lastargs = WIN32OLE::ARGV
5829      ret
5830    end
5831  
5832    # BSTR baseName
5833    # the base name of the node (nodename with the prefix stripped off)
5834    def baseName()
5835      ret = @dispatch._getproperty(34, [], [])
5836      @lastargs = WIN32OLE::ARGV
5837      ret
5838    end
5839  
5840    # IXMLDOMDocumentType doctype
5841    # node corresponding to the DOCTYPE
5842    def doctype()
5843      ret = @dispatch._getproperty(38, [], [])
5844      @lastargs = WIN32OLE::ARGV
5845      ret
5846    end
5847  
5848    # IXMLDOMImplementation implementation
5849    # info on this DOM implementation
5850    def implementation()
5851      ret = @dispatch._getproperty(39, [], [])
5852      @lastargs = WIN32OLE::ARGV
5853      ret
5854    end
5855  
5856    # IXMLDOMElement documentElement
5857    # the root of the tree
5858    def documentElement()
5859      ret = @dispatch._getproperty(40, [], [])
5860      @lastargs = WIN32OLE::ARGV
5861      ret
5862    end
5863  
5864    # I4 readyState
5865    # get the state of the XML document
5866    def readyState()
5867      ret = @dispatch._getproperty(-525, [], [])
5868      @lastargs = WIN32OLE::ARGV
5869      ret
5870    end
5871  
5872    # IXMLDOMParseError parseError
5873    # get the last parser error
5874    def parseError()
5875      ret = @dispatch._getproperty(59, [], [])
5876      @lastargs = WIN32OLE::ARGV
5877      ret
5878    end
5879  
5880    # BSTR url
5881    # get the URL for the loaded XML document
5882    def url()
5883      ret = @dispatch._getproperty(60, [], [])
5884      @lastargs = WIN32OLE::ARGV
5885      ret
5886    end
5887  
5888    # BOOL async
5889    # flag for asynchronous download
5890    def async()
5891      ret = @dispatch._getproperty(61, [], [])
5892      @lastargs = WIN32OLE::ARGV
5893      ret
5894    end
5895  
5896    # BOOL validateOnParse
5897    # indicates whether the parser performs validation
5898    def validateOnParse()
5899      ret = @dispatch._getproperty(65, [], [])
5900      @lastargs = WIN32OLE::ARGV
5901      ret
5902    end
5903  
5904    # BOOL resolveExternals
5905    # indicates whether the parser resolves references to external DTD/Entities/Schema
5906    def resolveExternals()
5907      ret = @dispatch._getproperty(66, [], [])
5908      @lastargs = WIN32OLE::ARGV
5909      ret
5910    end
5911  
5912    # BOOL preserveWhiteSpace
5913    # indicates whether the parser preserves whitespace
5914    def preserveWhiteSpace()
5915      ret = @dispatch._getproperty(67, [], [])
5916      @lastargs = WIN32OLE::ARGV
5917      ret
5918    end
5919  
5920    # VOID nodeValue
5921    # value stored in the node
5922    def nodeValue=(arg0)
5923      ret = @dispatch._setproperty(3, [arg0], [VT_VARIANT])
5924      @lastargs = WIN32OLE::ARGV
5925      ret
5926    end
5927  
5928    # VOID text
5929    # text content of the node and subtree
5930    def text=(arg0)
5931      ret = @dispatch._setproperty(24, [arg0], [VT_BSTR])
5932      @lastargs = WIN32OLE::ARGV
5933      ret
5934    end
5935  
5936    # VOID nodeTypedValue
5937    # get the strongly typed value of the node
5938    def nodeTypedValue=(arg0)
5939      ret = @dispatch._setproperty(25, [arg0], [VT_VARIANT])
5940      @lastargs = WIN32OLE::ARGV
5941      ret
5942    end
5943  
5944    # VOID dataType
5945    # the data type of the node
5946    def dataType=(arg0)
5947      ret = @dispatch._setproperty(26, [arg0], [VT_VARIANT])
5948      @lastargs = WIN32OLE::ARGV
5949      ret
5950    end
5951  
5952    # VOID async
5953    # flag for asynchronous download
5954    def async=(arg0)
5955      ret = @dispatch._setproperty(61, [arg0], [VT_BOOL])
5956      @lastargs = WIN32OLE::ARGV
5957      ret
5958    end
5959  
5960    # VOID validateOnParse
5961    # indicates whether the parser performs validation
5962    def validateOnParse=(arg0)
5963      ret = @dispatch._setproperty(65, [arg0], [VT_BOOL])
5964      @lastargs = WIN32OLE::ARGV
5965      ret
5966    end
5967  
5968    # VOID resolveExternals
5969    # indicates whether the parser resolves references to external DTD/Entities/Schema
5970    def resolveExternals=(arg0)
5971      ret = @dispatch._setproperty(66, [arg0], [VT_BOOL])
5972      @lastargs = WIN32OLE::ARGV
5973      ret
5974    end
5975  
5976    # VOID preserveWhiteSpace
5977    # indicates whether the parser preserves whitespace
5978    def preserveWhiteSpace=(arg0)
5979      ret = @dispatch._setproperty(67, [arg0], [VT_BOOL])
5980      @lastargs = WIN32OLE::ARGV
5981      ret
5982    end
5983  
5984    # VOID onreadystatechange
5985    # register a readystatechange event handler
5986    def onreadystatechange=(arg0)
5987      ret = @dispatch._setproperty(68, [arg0], [VT_VARIANT])
5988      @lastargs = WIN32OLE::ARGV
5989      ret
5990    end
5991  
5992    # VOID ondataavailable
5993    # register an ondataavailable event handler
5994    def ondataavailable=(arg0)
5995      ret = @dispatch._setproperty(69, [arg0], [VT_VARIANT])
5996      @lastargs = WIN32OLE::ARGV
5997      ret
5998    end
5999  
6000    # VOID ontransformnode
6001    # register an ontransformnode event handler
6002    def ontransformnode=(arg0)
6003      ret = @dispatch._setproperty(70, [arg0], [VT_VARIANT])
6004      @lastargs = WIN32OLE::ARGV
6005      ret
6006    end
6007  
6008    # IXMLDOMNode insertBefore
6009    # insert a child node
6010    #   IXMLDOMNode arg0 --- newChild [IN]
6011    #   VARIANT arg1 --- refChild [IN]
6012    def insertBefore(arg0, arg1)
6013      ret = @dispatch._invoke(13, [arg0, arg1], [VT_BYREF|VT_DISPATCH, VT_VARIANT])
6014      @lastargs = WIN32OLE::ARGV
6015      ret
6016    end
6017  
6018    # IXMLDOMNode replaceChild
6019    # replace a child node
6020    #   IXMLDOMNode arg0 --- newChild [IN]
6021    #   IXMLDOMNode arg1 --- oldChild [IN]
6022    def replaceChild(arg0, arg1)
6023      ret = @dispatch._invoke(14, [arg0, arg1], [VT_BYREF|VT_DISPATCH, VT_BYREF|VT_DISPATCH])
6024      @lastargs = WIN32OLE::ARGV
6025      ret
6026    end
6027  
6028    # IXMLDOMNode removeChild
6029    # remove a child node
6030    #   IXMLDOMNode arg0 --- childNode [IN]
6031    def removeChild(arg0)
6032      ret = @dispatch._invoke(15, [arg0], [VT_BYREF|VT_DISPATCH])
6033      @lastargs = WIN32OLE::ARGV
6034      ret
6035    end
6036  
6037    # IXMLDOMNode appendChild
6038    # append a child node
6039    #   IXMLDOMNode arg0 --- newChild [IN]
6040    def appendChild(arg0)
6041      ret = @dispatch._invoke(16, [arg0], [VT_BYREF|VT_DISPATCH])
6042      @lastargs = WIN32OLE::ARGV
6043      ret
6044    end
6045  
6046    # BOOL hasChildNodes
6047    def hasChildNodes()
6048      ret = @dispatch._invoke(17, [], [])
6049      @lastargs = WIN32OLE::ARGV
6050      ret
6051    end
6052  
6053    # IXMLDOMNode cloneNode
6054    #   BOOL arg0 --- deep [IN]
6055    def cloneNode(arg0)
6056      ret = @dispatch._invoke(19, [arg0], [VT_BOOL])
6057      @lastargs = WIN32OLE::ARGV
6058      ret
6059    end
6060  
6061    # BSTR transformNode
6062    # apply the stylesheet to the subtree
6063    #   IXMLDOMNode arg0 --- stylesheet [IN]
6064    def transformNode(arg0)
6065      ret = @dispatch._invoke(28, [arg0], [VT_BYREF|VT_DISPATCH])
6066      @lastargs = WIN32OLE::ARGV
6067      ret
6068    end
6069  
6070    # IXMLDOMNodeList selectNodes
6071    # execute query on the subtree
6072    #   BSTR arg0 --- queryString [IN]
6073    def selectNodes(arg0)
6074      ret = @dispatch._invoke(29, [arg0], [VT_BSTR])
6075      @lastargs = WIN32OLE::ARGV
6076      ret
6077    end
6078  
6079    # IXMLDOMNode selectSingleNode
6080    # execute query on the subtree
6081    #   BSTR arg0 --- queryString [IN]
6082    def selectSingleNode(arg0)
6083      ret = @dispatch._invoke(30, [arg0], [VT_BSTR])
6084      @lastargs = WIN32OLE::ARGV
6085      ret
6086    end
6087  
6088    # VOID transformNodeToObject
6089    # apply the stylesheet to the subtree, returning the result through a document or a stream
6090    #   IXMLDOMNode arg0 --- stylesheet [IN]
6091    #   VARIANT arg1 --- outputObject [IN]
6092    def transformNodeToObject(arg0, arg1)
6093      ret = @dispatch._invoke(35, [arg0, arg1], [VT_BYREF|VT_DISPATCH, VT_VARIANT])
6094      @lastargs = WIN32OLE::ARGV
6095      ret
6096    end
6097  
6098    # IXMLDOMElement createElement
6099    # create an Element node
6100    #   BSTR arg0 --- tagName [IN]
6101    def createElement(arg0)
6102      ret = @dispatch._invoke(41, [arg0], [VT_BSTR])
6103      @lastargs = WIN32OLE::ARGV
6104      ret
6105    end
6106  
6107    # IXMLDOMDocumentFragment createDocumentFragment
6108    # create a DocumentFragment node
6109    def createDocumentFragment()
6110      ret = @dispatch._invoke(42, [], [])
6111      @lastargs = WIN32OLE::ARGV
6112      ret
6113    end
6114  
6115    # IXMLDOMText createTextNode
6116    # create a text node
6117    #   BSTR arg0 --- data [IN]
6118    def createTextNode(arg0)
6119      ret = @dispatch._invoke(43, [arg0], [VT_BSTR])
6120      @lastargs = WIN32OLE::ARGV
6121      ret
6122    end
6123  
6124    # IXMLDOMComment createComment
6125    # create a comment node
6126    #   BSTR arg0 --- data [IN]
6127    def createComment(arg0)
6128      ret = @dispatch._invoke(44, [arg0], [VT_BSTR])
6129      @lastargs = WIN32OLE::ARGV
6130      ret
6131    end
6132  
6133    # IXMLDOMCDATASection createCDATASection
6134    # create a CDATA section node
6135    #   BSTR arg0 --- data [IN]
6136    def createCDATASection(arg0)
6137      ret = @dispatch._invoke(45, [arg0], [VT_BSTR])
6138      @lastargs = WIN32OLE::ARGV
6139      ret
6140    end
6141  
6142    # IXMLDOMProcessingInstruction createProcessingInstruction
6143    # create a processing instruction node
6144    #   BSTR arg0 --- target [IN]
6145    #   BSTR arg1 --- data [IN]
6146    def createProcessingInstruction(arg0, arg1)
6147      ret = @dispatch._invoke(46, [arg0, arg1], [VT_BSTR, VT_BSTR])
6148      @lastargs = WIN32OLE::ARGV
6149      ret
6150    end
6151  
6152    # IXMLDOMAttribute createAttribute
6153    # create an attribute node
6154    #   BSTR arg0 --- name [IN]
6155    def createAttribute(arg0)
6156      ret = @dispatch._invoke(47, [arg0], [VT_BSTR])
6157      @lastargs = WIN32OLE::ARGV
6158      ret
6159    end
6160  
6161    # IXMLDOMEntityReference createEntityReference
6162    # create an entity reference node
6163    #   BSTR arg0 --- name [IN]
6164    def createEntityReference(arg0)
6165      ret = @dispatch._invoke(49, [arg0], [VT_BSTR])
6166      @lastargs = WIN32OLE::ARGV
6167      ret
6168    end
6169  
6170    # IXMLDOMNodeList getElementsByTagName
6171    # build a list of elements by name
6172    #   BSTR arg0 --- tagName [IN]
6173    def getElementsByTagName(arg0)
6174      ret = @dispatch._invoke(50, [arg0], [VT_BSTR])
6175      @lastargs = WIN32OLE::ARGV
6176      ret
6177    end
6178  
6179    # IXMLDOMNode createNode
6180    # create a node of the specified node type and name
6181    #   VARIANT arg0 --- type [IN]
6182    #   BSTR arg1 --- name [IN]
6183    #   BSTR arg2 --- namespaceURI [IN]
6184    def createNode(arg0, arg1, arg2)
6185      ret = @dispatch._invoke(54, [arg0, arg1, arg2], [VT_VARIANT, VT_BSTR, VT_BSTR])
6186      @lastargs = WIN32OLE::ARGV
6187      ret
6188    end
6189  
6190    # IXMLDOMNode nodeFromID
6191    # retrieve node from it's ID
6192    #   BSTR arg0 --- idString [IN]
6193    def nodeFromID(arg0)
6194      ret = @dispatch._invoke(56, [arg0], [VT_BSTR])
6195      @lastargs = WIN32OLE::ARGV
6196      ret
6197    end
6198  
6199    # BOOL load
6200    # load document from the specified XML source
6201    #   VARIANT arg0 --- xmlSource [IN]
6202    def load(arg0)
6203      ret = @dispatch._invoke(58, [arg0], [VT_VARIANT])
6204      @lastargs = WIN32OLE::ARGV
6205      ret
6206    end
6207  
6208    # VOID abort
6209    # abort an asynchronous download
6210    def abort()
6211      ret = @dispatch._invoke(62, [], [])
6212      @lastargs = WIN32OLE::ARGV
6213      ret
6214    end
6215  
6216    # BOOL loadXML
6217    # load the document from a string
6218    #   BSTR arg0 --- bstrXML [IN]
6219    def loadXML(arg0)
6220      ret = @dispatch._invoke(63, [arg0], [VT_BSTR])
6221      @lastargs = WIN32OLE::ARGV
6222      ret
6223    end
6224  
6225    # VOID save
6226    # save the document to a specified desination
6227    #   VARIANT arg0 --- desination [IN]
6228    def save(arg0)
6229      ret = @dispatch._invoke(64, [arg0], [VT_VARIANT])
6230      @lastargs = WIN32OLE::ARGV
6231      ret
6232    end
6233  
6234    # HRESULT ondataavailable EVENT in XMLDOMDocumentEvents
6235    def ondataavailable()
6236      ret = @dispatch._invoke(198, [], [])
6237      @lastargs = WIN32OLE::ARGV
6238      ret
6239    end
6240  
6241    # HRESULT onreadystatechange EVENT in XMLDOMDocumentEvents
6242    def onreadystatechange()
6243      ret = @dispatch._invoke(-609, [], [])
6244      @lastargs = WIN32OLE::ARGV
6245      ret
6246    end
6247  end
6248  
6249  # W3C-DOM XML Document (Apartment)
6250  class Microsoft_FreeThreadedXMLDOM_1_0 # DOMFreeThreadedDocument
6251    include WIN32OLE::VARIANT
6252    attr_reader :lastargs
6253    attr_reader :dispatch
6254    attr_reader :clsid
6255    attr_reader :progid
6256  
6257    def initialize(obj = nil)
6258      @clsid = "{2933BF91-7B36-11D2-B20E-00C04F983E60}"
6259      @progid = "Microsoft.FreeThreadedXMLDOM.1.0"
6260      if obj.nil?
6261        @dispatch = WIN32OLE.new @progid
6262      else
6263        @dispatch = obj
6264      end
6265    end
6266  
6267    def method_missing(cmd, *arg)
6268      @dispatch.method_missing(cmd, *arg)
6269    end
6270  
6271    # BSTR nodeName
6272    # name of the node
6273    def nodeName()
6274      ret = @dispatch._getproperty(2, [], [])
6275      @lastargs = WIN32OLE::ARGV
6276      ret
6277    end
6278  
6279    # VARIANT nodeValue
6280    # value stored in the node
6281    def nodeValue()
6282      ret = @dispatch._getproperty(3, [], [])
6283      @lastargs = WIN32OLE::ARGV
6284      ret
6285    end
6286  
6287    # DOMNodeType nodeType
6288    # the node's type
6289    def nodeType()
6290      ret = @dispatch._getproperty(4, [], [])
6291      @lastargs = WIN32OLE::ARGV
6292      ret
6293    end
6294  
6295    # IXMLDOMNode parentNode
6296    # parent of the node
6297    def parentNode()
6298      ret = @dispatch._getproperty(6, [], [])
6299      @lastargs = WIN32OLE::ARGV
6300      ret
6301    end
6302  
6303    # IXMLDOMNodeList childNodes
6304    # the collection of the node's children
6305    def childNodes()
6306      ret = @dispatch._getproperty(7, [], [])
6307      @lastargs = WIN32OLE::ARGV
6308      ret
6309    end
6310  
6311    # IXMLDOMNode firstChild
6312    # first child of the node
6313    def firstChild()
6314      ret = @dispatch._getproperty(8, [], [])
6315      @lastargs = WIN32OLE::ARGV
6316      ret
6317    end
6318  
6319    # IXMLDOMNode lastChild
6320    # first child of the node
6321    def lastChild()
6322      ret = @dispatch._getproperty(9, [], [])
6323      @lastargs = WIN32OLE::ARGV
6324      ret
6325    end
6326  
6327    # IXMLDOMNode previousSibling
6328    # left sibling of the node
6329    def previousSibling()
6330      ret = @dispatch._getproperty(10, [], [])
6331      @lastargs = WIN32OLE::ARGV
6332      ret
6333    end
6334  
6335    # IXMLDOMNode nextSibling
6336    # right sibling of the node
6337    def nextSibling()
6338      ret = @dispatch._getproperty(11, [], [])
6339      @lastargs = WIN32OLE::ARGV
6340      ret
6341    end
6342  
6343    # IXMLDOMNamedNodeMap attributes
6344    # the collection of the node's attributes
6345    def attributes()
6346      ret = @dispatch._getproperty(12, [], [])
6347      @lastargs = WIN32OLE::ARGV
6348      ret
6349    end
6350  
6351    # IXMLDOMDocument ownerDocument
6352    # document that contains the node
6353    def ownerDocument()
6354      ret = @dispatch._getproperty(18, [], [])
6355      @lastargs = WIN32OLE::ARGV
6356      ret
6357    end
6358  
6359    # BSTR nodeTypeString
6360    # the type of node in string form
6361    def nodeTypeString()
6362      ret = @dispatch._getproperty(21, [], [])
6363      @lastargs = WIN32OLE::ARGV
6364      ret
6365    end
6366  
6367    # BSTR text
6368    # text content of the node and subtree
6369    def text()
6370      ret = @dispatch._getproperty(24, [], [])
6371      @lastargs = WIN32OLE::ARGV
6372      ret
6373    end
6374  
6375    # BOOL specified
6376    # indicates whether node is a default value
6377    def specified()
6378      ret = @dispatch._getproperty(22, [], [])
6379      @lastargs = WIN32OLE::ARGV
6380      ret
6381    end
6382  
6383    # IXMLDOMNode definition
6384    # pointer to the definition of the node in the DTD or schema
6385    def definition()
6386      ret = @dispatch._getproperty(23, [], [])
6387      @lastargs = WIN32OLE::ARGV
6388      ret
6389    end
6390  
6391    # VARIANT nodeTypedValue
6392    # get the strongly typed value of the node
6393    def nodeTypedValue()
6394      ret = @dispatch._getproperty(25, [], [])
6395      @lastargs = WIN32OLE::ARGV
6396      ret
6397    end
6398  
6399    # VARIANT dataType
6400    # the data type of the node
6401    def dataType()
6402      ret = @dispatch._getproperty(26, [], [])
6403      @lastargs = WIN32OLE::ARGV
6404      ret
6405    end
6406  
6407    # BSTR xml
6408    # return the XML source for the node and each of its descendants
6409    def xml()
6410      ret = @dispatch._getproperty(27, [], [])
6411      @lastargs = WIN32OLE::ARGV
6412      ret
6413    end
6414  
6415    # BOOL parsed
6416    # has sub-tree been completely parsed
6417    def parsed()
6418      ret = @dispatch._getproperty(31, [], [])
6419      @lastargs = WIN32OLE::ARGV
6420      ret
6421    end
6422  
6423    # BSTR namespaceURI
6424    # the URI for the namespace applying to the node
6425    def namespaceURI()
6426      ret = @dispatch._getproperty(32, [], [])
6427      @lastargs = WIN32OLE::ARGV
6428      ret
6429    end
6430  
6431    # BSTR prefix
6432    # the prefix for the namespace applying to the node
6433    def prefix()
6434      ret = @dispatch._getproperty(33, [], [])
6435      @lastargs = WIN32OLE::ARGV
6436      ret
6437    end
6438  
6439    # BSTR baseName
6440    # the base name of the node (nodename with the prefix stripped off)
6441    def baseName()
6442      ret = @dispatch._getproperty(34, [], [])
6443      @lastargs = WIN32OLE::ARGV
6444      ret
6445    end
6446  
6447    # IXMLDOMDocumentType doctype
6448    # node corresponding to the DOCTYPE
6449    def doctype()
6450      ret = @dispatch._getproperty(38, [], [])
6451      @lastargs = WIN32OLE::ARGV
6452      ret
6453    end
6454  
6455    # IXMLDOMImplementation implementation
6456    # info on this DOM implementation
6457    def implementation()
6458      ret = @dispatch._getproperty(39, [], [])
6459      @lastargs = WIN32OLE::ARGV
6460      ret
6461    end
6462  
6463    # IXMLDOMElement documentElement
6464    # the root of the tree
6465    def documentElement()
6466      ret = @dispatch._getproperty(40, [], [])
6467      @lastargs = WIN32OLE::ARGV
6468      ret
6469    end
6470  
6471    # I4 readyState
6472    # get the state of the XML document
6473    def readyState()
6474      ret = @dispatch._getproperty(-525, [], [])
6475      @lastargs = WIN32OLE::ARGV
6476      ret
6477    end
6478  
6479    # IXMLDOMParseError parseError
6480    # get the last parser error
6481    def parseError()
6482      ret = @dispatch._getproperty(59, [], [])
6483      @lastargs = WIN32OLE::ARGV
6484      ret
6485    end
6486  
6487    # BSTR url
6488    # get the URL for the loaded XML document
6489    def url()
6490      ret = @dispatch._getproperty(60, [], [])
6491      @lastargs = WIN32OLE::ARGV
6492      ret
6493    end
6494  
6495    # BOOL async
6496    # flag for asynchronous download
6497    def async()
6498      ret = @dispatch._getproperty(61, [], [])
6499      @lastargs = WIN32OLE::ARGV
6500      ret
6501    end
6502  
6503    # BOOL validateOnParse
6504    # indicates whether the parser performs validation
6505    def validateOnParse()
6506      ret = @dispatch._getproperty(65, [], [])
6507      @lastargs = WIN32OLE::ARGV
6508      ret
6509    end
6510  
6511    # BOOL resolveExternals
6512    # indicates whether the parser resolves references to external DTD/Entities/Schema
6513    def resolveExternals()
6514      ret = @dispatch._getproperty(66, [], [])
6515      @lastargs = WIN32OLE::ARGV
6516      ret
6517    end
6518  
6519    # BOOL preserveWhiteSpace
6520    # indicates whether the parser preserves whitespace
6521    def preserveWhiteSpace()
6522      ret = @dispatch._getproperty(67, [], [])
6523      @lastargs = WIN32OLE::ARGV
6524      ret
6525    end
6526  
6527    # VOID nodeValue
6528    # value stored in the node
6529    def nodeValue=(arg0)
6530      ret = @dispatch._setproperty(3, [arg0], [VT_VARIANT])
6531      @lastargs = WIN32OLE::ARGV
6532      ret
6533    end
6534  
6535    # VOID text
6536    # text content of the node and subtree
6537    def text=(arg0)
6538      ret = @dispatch._setproperty(24, [arg0], [VT_BSTR])
6539      @lastargs = WIN32OLE::ARGV
6540      ret
6541    end
6542  
6543    # VOID nodeTypedValue
6544    # get the strongly typed value of the node
6545    def nodeTypedValue=(arg0)
6546      ret = @dispatch._setproperty(25, [arg0], [VT_VARIANT])
6547      @lastargs = WIN32OLE::ARGV
6548      ret
6549    end
6550  
6551    # VOID dataType
6552    # the data type of the node
6553    def dataType=(arg0)
6554      ret = @dispatch._setproperty(26, [arg0], [VT_VARIANT])
6555      @lastargs = WIN32OLE::ARGV
6556      ret
6557    end
6558  
6559    # VOID async
6560    # flag for asynchronous download
6561    def async=(arg0)
6562      ret = @dispatch._setproperty(61, [arg0], [VT_BOOL])
6563      @lastargs = WIN32OLE::ARGV
6564      ret
6565    end
6566  
6567    # VOID validateOnParse
6568    # indicates whether the parser performs validation
6569    def validateOnParse=(arg0)
6570      ret = @dispatch._setproperty(65, [arg0], [VT_BOOL])
6571      @lastargs = WIN32OLE::ARGV
6572      ret
6573    end
6574  
6575    # VOID resolveExternals
6576    # indicates whether the parser resolves references to external DTD/Entities/Schema
6577    def resolveExternals=(arg0)
6578      ret = @dispatch._setproperty(66, [arg0], [VT_BOOL])
6579      @lastargs = WIN32OLE::ARGV
6580      ret
6581    end
6582  
6583    # VOID preserveWhiteSpace
6584    # indicates whether the parser preserves whitespace
6585    def preserveWhiteSpace=(arg0)
6586      ret = @dispatch._setproperty(67, [arg0], [VT_BOOL])
6587      @lastargs = WIN32OLE::ARGV
6588      ret
6589    end
6590  
6591    # VOID onreadystatechange
6592    # register a readystatechange event handler
6593    def onreadystatechange=(arg0)
6594      ret = @dispatch._setproperty(68, [arg0], [VT_VARIANT])
6595      @lastargs = WIN32OLE::ARGV
6596      ret
6597    end
6598  
6599    # VOID ondataavailable
6600    # register an ondataavailable event handler
6601    def ondataavailable=(arg0)
6602      ret = @dispatch._setproperty(69, [arg0], [VT_VARIANT])
6603      @lastargs = WIN32OLE::ARGV
6604      ret
6605    end
6606  
6607    # VOID ontransformnode
6608    # register an ontransformnode event handler
6609    def ontransformnode=(arg0)
6610      ret = @dispatch._setproperty(70, [arg0], [VT_VARIANT])
6611      @lastargs = WIN32OLE::ARGV
6612      ret
6613    end
6614  
6615    # IXMLDOMNode insertBefore
6616    # insert a child node
6617    #   IXMLDOMNode arg0 --- newChild [IN]
6618    #   VARIANT arg1 --- refChild [IN]
6619    def insertBefore(arg0, arg1)
6620      ret = @dispatch._invoke(13, [arg0, arg1], [VT_BYREF|VT_DISPATCH, VT_VARIANT])
6621      @lastargs = WIN32OLE::ARGV
6622      ret
6623    end
6624  
6625    # IXMLDOMNode replaceChild
6626    # replace a child node
6627    #   IXMLDOMNode arg0 --- newChild [IN]
6628    #   IXMLDOMNode arg1 --- oldChild [IN]
6629    def replaceChild(arg0, arg1)
6630      ret = @dispatch._invoke(14, [arg0, arg1], [VT_BYREF|VT_DISPATCH, VT_BYREF|VT_DISPATCH])
6631      @lastargs = WIN32OLE::ARGV
6632      ret
6633    end
6634  
6635    # IXMLDOMNode removeChild
6636    # remove a child node
6637    #   IXMLDOMNode arg0 --- childNode [IN]
6638    def removeChild(arg0)
6639      ret = @dispatch._invoke(15, [arg0], [VT_BYREF|VT_DISPATCH])
6640      @lastargs = WIN32OLE::ARGV
6641      ret
6642    end
6643  
6644    # IXMLDOMNode appendChild
6645    # append a child node
6646    #   IXMLDOMNode arg0 --- newChild [IN]
6647    def appendChild(arg0)
6648      ret = @dispatch._invoke(16, [arg0], [VT_BYREF|VT_DISPATCH])
6649      @lastargs = WIN32OLE::ARGV
6650      ret
6651    end
6652  
6653    # BOOL hasChildNodes
6654    def hasChildNodes()
6655      ret = @dispatch._invoke(17, [], [])
6656      @lastargs = WIN32OLE::ARGV
6657      ret
6658    end
6659  
6660    # IXMLDOMNode cloneNode
6661    #   BOOL arg0 --- deep [IN]
6662    def cloneNode(arg0)
6663      ret = @dispatch._invoke(19, [arg0], [VT_BOOL])
6664      @lastargs = WIN32OLE::ARGV
6665      ret
6666    end
6667  
6668    # BSTR transformNode
6669    # apply the stylesheet to the subtree
6670    #   IXMLDOMNode arg0 --- stylesheet [IN]
6671    def transformNode(arg0)
6672      ret = @dispatch._invoke(28, [arg0], [VT_BYREF|VT_DISPATCH])
6673      @lastargs = WIN32OLE::ARGV
6674      ret
6675    end
6676  
6677    # IXMLDOMNodeList selectNodes
6678    # execute query on the subtree
6679    #   BSTR arg0 --- queryString [IN]
6680    def selectNodes(arg0)
6681      ret = @dispatch._invoke(29, [arg0], [VT_BSTR])
6682      @lastargs = WIN32OLE::ARGV
6683      ret
6684    end
6685  
6686    # IXMLDOMNode selectSingleNode
6687    # execute query on the subtree
6688    #   BSTR arg0 --- queryString [IN]
6689    def selectSingleNode(arg0)
6690      ret = @dispatch._invoke(30, [arg0], [VT_BSTR])
6691      @lastargs = WIN32OLE::ARGV
6692      ret
6693    end
6694  
6695    # VOID transformNodeToObject
6696    # apply the stylesheet to the subtree, returning the result through a document or a stream
6697    #   IXMLDOMNode arg0 --- stylesheet [IN]
6698    #   VARIANT arg1 --- outputObject [IN]
6699    def transformNodeToObject(arg0, arg1)
6700      ret = @dispatch._invoke(35, [arg0, arg1], [VT_BYREF|VT_DISPATCH, VT_VARIANT])
6701      @lastargs = WIN32OLE::ARGV
6702      ret
6703    end
6704  
6705    # IXMLDOMElement createElement
6706    # create an Element node
6707    #   BSTR arg0 --- tagName [IN]
6708    def createElement(arg0)
6709      ret = @dispatch._invoke(41, [arg0], [VT_BSTR])
6710      @lastargs = WIN32OLE::ARGV
6711      ret
6712    end
6713  
6714    # IXMLDOMDocumentFragment createDocumentFragment
6715    # create a DocumentFragment node
6716    def createDocumentFragment()
6717      ret = @dispatch._invoke(42, [], [])
6718      @lastargs = WIN32OLE::ARGV
6719      ret
6720    end
6721  
6722    # IXMLDOMText createTextNode
6723    # create a text node
6724    #   BSTR arg0 --- data [IN]
6725    def createTextNode(arg0)
6726      ret = @dispatch._invoke(43, [arg0], [VT_BSTR])
6727      @lastargs = WIN32OLE::ARGV
6728      ret
6729    end
6730  
6731    # IXMLDOMComment createComment
6732    # create a comment node
6733    #   BSTR arg0 --- data [IN]
6734    def createComment(arg0)
6735      ret = @dispatch._invoke(44, [arg0], [VT_BSTR])
6736      @lastargs = WIN32OLE::ARGV
6737      ret
6738    end
6739  
6740    # IXMLDOMCDATASection createCDATASection
6741    # create a CDATA section node
6742    #   BSTR arg0 --- data [IN]
6743    def createCDATASection(arg0)
6744      ret = @dispatch._invoke(45, [arg0], [VT_BSTR])
6745      @lastargs = WIN32OLE::ARGV
6746      ret
6747    end
6748  
6749    # IXMLDOMProcessingInstruction createProcessingInstruction
6750    # create a processing instruction node
6751    #   BSTR arg0 --- target [IN]
6752    #   BSTR arg1 --- data [IN]
6753    def createProcessingInstruction(arg0, arg1)
6754      ret = @dispatch._invoke(46, [arg0, arg1], [VT_BSTR, VT_BSTR])
6755      @lastargs = WIN32OLE::ARGV
6756      ret
6757    end
6758  
6759    # IXMLDOMAttribute createAttribute
6760    # create an attribute node
6761    #   BSTR arg0 --- name [IN]
6762    def createAttribute(arg0)
6763      ret = @dispatch._invoke(47, [arg0], [VT_BSTR])
6764      @lastargs = WIN32OLE::ARGV
6765      ret
6766    end
6767  
6768    # IXMLDOMEntityReference createEntityReference
6769    # create an entity reference node
6770    #   BSTR arg0 --- name [IN]
6771    def createEntityReference(arg0)
6772      ret = @dispatch._invoke(49, [arg0], [VT_BSTR])
6773      @lastargs = WIN32OLE::ARGV
6774      ret
6775    end
6776  
6777    # IXMLDOMNodeList getElementsByTagName
6778    # build a list of elements by name
6779    #   BSTR arg0 --- tagName [IN]
6780    def getElementsByTagName(arg0)
6781      ret = @dispatch._invoke(50, [arg0], [VT_BSTR])
6782      @lastargs = WIN32OLE::ARGV
6783      ret
6784    end
6785  
6786    # IXMLDOMNode createNode
6787    # create a node of the specified node type and name
6788    #   VARIANT arg0 --- type [IN]
6789    #   BSTR arg1 --- name [IN]
6790    #   BSTR arg2 --- namespaceURI [IN]
6791    def createNode(arg0, arg1, arg2)
6792      ret = @dispatch._invoke(54, [arg0, arg1, arg2], [VT_VARIANT, VT_BSTR, VT_BSTR])
6793      @lastargs = WIN32OLE::ARGV
6794      ret
6795    end
6796  
6797    # IXMLDOMNode nodeFromID
6798    # retrieve node from it's ID
6799    #   BSTR arg0 --- idString [IN]
6800    def nodeFromID(arg0)
6801      ret = @dispatch._invoke(56, [arg0], [VT_BSTR])
6802      @lastargs = WIN32OLE::ARGV
6803      ret
6804    end
6805  
6806    # BOOL load
6807    # load document from the specified XML source
6808    #   VARIANT arg0 --- xmlSource [IN]
6809    def load(arg0)
6810      ret = @dispatch._invoke(58, [arg0], [VT_VARIANT])
6811      @lastargs = WIN32OLE::ARGV
6812      ret
6813    end
6814  
6815    # VOID abort
6816    # abort an asynchronous download
6817    def abort()
6818      ret = @dispatch._invoke(62, [], [])
6819      @lastargs = WIN32OLE::ARGV
6820      ret
6821    end
6822  
6823    # BOOL loadXML
6824    # load the document from a string
6825    #   BSTR arg0 --- bstrXML [IN]
6826    def loadXML(arg0)
6827      ret = @dispatch._invoke(63, [arg0], [VT_BSTR])
6828      @lastargs = WIN32OLE::ARGV
6829      ret
6830    end
6831  
6832    # VOID save
6833    # save the document to a specified desination
6834    #   VARIANT arg0 --- desination [IN]
6835    def save(arg0)
6836      ret = @dispatch._invoke(64, [arg0], [VT_VARIANT])
6837      @lastargs = WIN32OLE::ARGV
6838      ret
6839    end
6840  
6841    # HRESULT ondataavailable EVENT in XMLDOMDocumentEvents
6842    def ondataavailable()
6843      ret = @dispatch._invoke(198, [], [])
6844      @lastargs = WIN32OLE::ARGV
6845      ret
6846    end
6847  
6848    # HRESULT onreadystatechange EVENT in XMLDOMDocumentEvents
6849    def onreadystatechange()
6850      ret = @dispatch._invoke(-609, [], [])
6851      @lastargs = WIN32OLE::ARGV
6852      ret
6853    end
6854  end
6855  
6856  # IXMLHttpRequest Interface
6857  module IXMLHttpRequest
6858    include WIN32OLE::VARIANT
6859    attr_reader :lastargs
6860  
6861    # I4 status
6862    # Get HTTP status code
6863    def status()
6864      ret = _getproperty(7, [], [])
6865      @lastargs = WIN32OLE::ARGV
6866      ret
6867    end
6868  
6869    # BSTR statusText
6870    # Get HTTP status text
6871    def statusText()
6872      ret = _getproperty(8, [], [])
6873      @lastargs = WIN32OLE::ARGV
6874      ret
6875    end
6876  
6877    # DISPATCH responseXML
6878    # Get response body
6879    def responseXML()
6880      ret = _getproperty(9, [], [])
6881      @lastargs = WIN32OLE::ARGV
6882      ret
6883    end
6884  
6885    # BSTR responseText
6886    # Get response body
6887    def responseText()
6888      ret = _getproperty(10, [], [])
6889      @lastargs = WIN32OLE::ARGV
6890      ret
6891    end
6892  
6893    # VARIANT responseBody
6894    # Get response body
6895    def responseBody()
6896      ret = _getproperty(11, [], [])
6897      @lastargs = WIN32OLE::ARGV
6898      ret
6899    end
6900  
6901    # VARIANT responseStream
6902    # Get response body
6903    def responseStream()
6904      ret = _getproperty(12, [], [])
6905      @lastargs = WIN32OLE::ARGV
6906      ret
6907    end
6908  
6909    # I4 readyState
6910    # Get ready state
6911    def readyState()
6912      ret = _getproperty(13, [], [])
6913      @lastargs = WIN32OLE::ARGV
6914      ret
6915    end
6916  
6917    # VOID onreadystatechange
6918    # Register a complete event handler
6919    def onreadystatechange=(arg0)
6920      ret = _setproperty(14, [arg0], [VT_VARIANT])
6921      @lastargs = WIN32OLE::ARGV
6922      ret
6923    end
6924  
6925    # VOID open
6926    # Open HTTP connection
6927    #   BSTR arg0 --- bstrMethod [IN]
6928    #   BSTR arg1 --- bstrUrl [IN]
6929    #   VARIANT arg2 --- varAsync [IN]
6930    #   VARIANT arg3 --- bstrUser [IN]
6931    #   VARIANT arg4 --- bstrPassword [IN]
6932    def open(arg0, arg1, arg2=nil, arg3=nil, arg4=nil)
6933      ret = _invoke(1, [arg0, arg1, arg2, arg3, arg4], [VT_BSTR, VT_BSTR, VT_VARIANT, VT_VARIANT, VT_VARIANT])
6934      @lastargs = WIN32OLE::ARGV
6935      ret
6936    end
6937  
6938    # VOID setRequestHeader
6939    # Add HTTP request header
6940    #   BSTR arg0 --- bstrHeader [IN]
6941    #   BSTR arg1 --- bstrValue [IN]
6942    def setRequestHeader(arg0, arg1)
6943      ret = _invoke(2, [arg0, arg1], [VT_BSTR, VT_BSTR])
6944      @lastargs = WIN32OLE::ARGV
6945      ret
6946    end
6947  
6948    # BSTR getResponseHeader
6949    # Get HTTP response header
6950    #   BSTR arg0 --- bstrHeader [IN]
6951    def getResponseHeader(arg0)
6952      ret = _invoke(3, [arg0], [VT_BSTR])
6953      @lastargs = WIN32OLE::ARGV
6954      ret
6955    end
6956  
6957    # BSTR getAllResponseHeaders
6958    # Get all HTTP response headers
6959    def getAllResponseHeaders()
6960      ret = _invoke(4, [], [])
6961      @lastargs = WIN32OLE::ARGV
6962      ret
6963    end
6964  
6965    # VOID send
6966    # Send HTTP request
6967    #   VARIANT arg0 --- varBody [IN]
6968    def send(arg0=nil)
6969      ret = _invoke(5, [arg0], [VT_VARIANT])
6970      @lastargs = WIN32OLE::ARGV
6971      ret
6972    end
6973  
6974    # VOID abort
6975    # Abort HTTP request
6976    def abort()
6977      ret = _invoke(6, [], [])
6978      @lastargs = WIN32OLE::ARGV
6979      ret
6980    end
6981  end
6982  
6983  # XML HTTP Request class.
6984  class Microsoft_XMLHTTP_1 # XMLHTTPRequest
6985    include WIN32OLE::VARIANT
6986    attr_reader :lastargs
6987    attr_reader :dispatch
6988    attr_reader :clsid
6989    attr_reader :progid
6990  
6991    def initialize(obj = nil)
6992      @clsid = "{ED8C108E-4349-11D2-91A4-00C04F7969E8}"
6993      @progid = "Microsoft.XMLHTTP.1"
6994      if obj.nil?
6995        @dispatch = WIN32OLE.new @progid
6996      else
6997        @dispatch = obj
6998      end
6999    end
7000  
7001    def method_missing(cmd, *arg)
7002      @dispatch.method_missing(cmd, *arg)
7003    end
7004  
7005    # I4 status
7006    # Get HTTP status code
7007    def status()
7008      ret = @dispatch._getproperty(7, [], [])
7009      @lastargs = WIN32OLE::ARGV
7010      ret
7011    end
7012  
7013    # BSTR statusText
7014    # Get HTTP status text
7015    def statusText()
7016      ret = @dispatch._getproperty(8, [], [])
7017      @lastargs = WIN32OLE::ARGV
7018      ret
7019    end
7020  
7021    # DISPATCH responseXML
7022    # Get response body
7023    def responseXML()
7024      ret = @dispatch._getproperty(9, [], [])
7025      @lastargs = WIN32OLE::ARGV
7026      ret
7027    end
7028  
7029    # BSTR responseText
7030    # Get response body
7031    def responseText()
7032      ret = @dispatch._getproperty(10, [], [])
7033      @lastargs = WIN32OLE::ARGV
7034      ret
7035    end
7036  
7037    # VARIANT responseBody
7038    # Get response body
7039    def responseBody()
7040      ret = @dispatch._getproperty(11, [], [])
7041      @lastargs = WIN32OLE::ARGV
7042      ret
7043    end
7044  
7045    # VARIANT responseStream
7046    # Get response body
7047    def responseStream()
7048      ret = @dispatch._getproperty(12, [], [])
7049      @lastargs = WIN32OLE::ARGV
7050      ret
7051    end
7052  
7053    # I4 readyState
7054    # Get ready state
7055    def readyState()
7056      ret = @dispatch._getproperty(13, [], [])
7057      @lastargs = WIN32OLE::ARGV
7058      ret
7059    end
7060  
7061    # VOID onreadystatechange
7062    # Register a complete event handler
7063    def onreadystatechange=(arg0)
7064      ret = @dispatch._setproperty(14, [arg0], [VT_VARIANT])
7065      @lastargs = WIN32OLE::ARGV
7066      ret
7067    end
7068  
7069    # VOID open
7070    # Open HTTP connection
7071    #   BSTR arg0 --- bstrMethod [IN]
7072    #   BSTR arg1 --- bstrUrl [IN]
7073    #   VARIANT arg2 --- varAsync [IN]
7074    #   VARIANT arg3 --- bstrUser [IN]
7075    #   VARIANT arg4 --- bstrPassword [IN]
7076    def open(arg0, arg1, arg2=nil, arg3=nil, arg4=nil)
7077      ret = @dispatch._invoke(1, [arg0, arg1, arg2, arg3, arg4], [VT_BSTR, VT_BSTR, VT_VARIANT, VT_VARIANT, VT_VARIANT])
7078      @lastargs = WIN32OLE::ARGV
7079      ret
7080    end
7081  
7082    # VOID setRequestHeader
7083    # Add HTTP request header
7084    #   BSTR arg0 --- bstrHeader [IN]
7085    #   BSTR arg1 --- bstrValue [IN]
7086    def setRequestHeader(arg0, arg1)
7087      ret = @dispatch._invoke(2, [arg0, arg1], [VT_BSTR, VT_BSTR])
7088      @lastargs = WIN32OLE::ARGV
7089      ret
7090    end
7091  
7092    # BSTR getResponseHeader
7093    # Get HTTP response header
7094    #   BSTR arg0 --- bstrHeader [IN]
7095    def getResponseHeader(arg0)
7096      ret = @dispatch._invoke(3, [arg0], [VT_BSTR])
7097      @lastargs = WIN32OLE::ARGV
7098      ret
7099    end
7100  
7101    # BSTR getAllResponseHeaders
7102    # Get all HTTP response headers
7103    def getAllResponseHeaders()
7104      ret = @dispatch._invoke(4, [], [])
7105      @lastargs = WIN32OLE::ARGV
7106      ret
7107    end
7108  
7109    # VOID send
7110    # Send HTTP request
7111    #   VARIANT arg0 --- varBody [IN]
7112    def send(arg0=nil)
7113      ret = @dispatch._invoke(5, [arg0], [VT_VARIANT])
7114      @lastargs = WIN32OLE::ARGV
7115      ret
7116    end
7117  
7118    # VOID abort
7119    # Abort HTTP request
7120    def abort()
7121      ret = @dispatch._invoke(6, [], [])
7122      @lastargs = WIN32OLE::ARGV
7123      ret
7124    end
7125  end
7126  
7127  # XML Data Source Object
7128  class Microsoft_XMLDSO_1_0 # XMLDSOControl
7129    include WIN32OLE::VARIANT
7130    attr_reader :lastargs
7131    attr_reader :dispatch
7132    attr_reader :clsid
7133    attr_reader :progid
7134  
7135    def initialize(obj = nil)
7136      @clsid = "{550DDA30-0541-11D2-9CA9-0060B0EC3D39}"
7137      @progid = "Microsoft.XMLDSO.1.0"
7138      if obj.nil?
7139        @dispatch = WIN32OLE.new @progid
7140      else
7141        @dispatch = obj
7142      end
7143    end
7144  
7145    def method_missing(cmd, *arg)
7146      @dispatch.method_missing(cmd, *arg)
7147    end
7148  
7149    # IXMLDOMDocument XMLDocument
7150    def XMLDocument()
7151      ret = @dispatch._getproperty(65537, [], [])
7152      @lastargs = WIN32OLE::ARGV
7153      ret
7154    end
7155  
7156    # I4 JavaDSOCompatible
7157    def JavaDSOCompatible()
7158      ret = @dispatch._getproperty(65538, [], [])
7159      @lastargs = WIN32OLE::ARGV
7160      ret
7161    end
7162  
7163    # I4 readyState
7164    def readyState()
7165      ret = @dispatch._getproperty(-525, [], [])
7166      @lastargs = WIN32OLE::ARGV
7167      ret
7168    end
7169  
7170    # VOID XMLDocument
7171    def XMLDocument=(arg0)
7172      ret = @dispatch._setproperty(65537, [arg0], [VT_BYREF|VT_DISPATCH])
7173      @lastargs = WIN32OLE::ARGV
7174      ret
7175    end
7176  
7177    # VOID JavaDSOCompatible
7178    def JavaDSOCompatible=(arg0)
7179      ret = @dispatch._setproperty(65538, [arg0], [VT_I4])
7180      @lastargs = WIN32OLE::ARGV
7181      ret
7182    end
7183  end
7184  
7185  # Constants that define types for IXMLElement.
7186  module OLEtagXMLEMEM_TYPE
7187    include WIN32OLE::VARIANT
7188    attr_reader :lastargs
7189    XMLELEMTYPE_ELEMENT = 0
7190    XMLELEMTYPE_TEXT = 1
7191    XMLELEMTYPE_COMMENT = 2
7192    XMLELEMTYPE_DOCUMENT = 3
7193    XMLELEMTYPE_DTD = 4
7194    XMLELEMTYPE_PI = 5
7195    XMLELEMTYPE_OTHER = 6
7196  end
7197  
7198  # XMLDocument extends IXML Document.  It is obsolete.  You should use DOMDocument.  This object should not be confused with the XMLDocument property on the XML data island.
7199  class Msxml # XMLDocument
7200    include WIN32OLE::VARIANT
7201    attr_reader :lastargs
7202    attr_reader :dispatch
7203    attr_reader :clsid
7204    attr_reader :progid
7205  
7206    def initialize(obj = nil)
7207      @clsid = "{CFC399AF-D876-11D0-9C10-00C04FC99C8E}"
7208      @progid = "Msxml"
7209      if obj.nil?
7210        @dispatch = WIN32OLE.new @progid
7211      else
7212        @dispatch = obj
7213      end
7214    end
7215  
7216    def method_missing(cmd, *arg)
7217      @dispatch.method_missing(cmd, *arg)
7218    end
7219  
7220    # HRESULT url
7221    # set URL to load an XML document from the URL.
7222    #   BSTR arg0 --- p [IN]
7223    def url=(arg0)
7224      ret = @dispatch._setproperty(65641, [arg0], [VT_BSTR, VT_HRESULT])
7225      @lastargs = WIN32OLE::ARGV
7226      ret
7227    end
7228  
7229    # HRESULT charset
7230    # get encoding.
7231    #   BSTR arg0 --- p [IN]
7232    def charset=(arg0)
7233      ret = @dispatch._setproperty(65645, [arg0], [VT_BSTR, VT_HRESULT])
7234      @lastargs = WIN32OLE::ARGV
7235      ret
7236    end
7237  
7238    # HRESULT async
7239    # get asynchronous loading flag.
7240    #   BOOL arg0 --- pf [IN]
7241    def async=(arg0)
7242      ret = @dispatch._setproperty(65649, [arg0], [VT_BOOL, VT_HRESULT])
7243      @lastargs = WIN32OLE::ARGV
7244      ret
7245    end
7246  
7247    # HRESULT root
7248    # get root IXMLElement of the XML document.
7249    #   IXMLElement2,IXMLElement2 arg0 --- p [OUT]
7250    def root
7251      OLEProperty.new(@dispatch, 65637, [VT_BYREF|VT_BYREF|VT_DISPATCH], [VT_BYREF|VT_BYREF|VT_DISPATCH, VT_HRESULT])
7252    end
7253  
7254    # HRESULT url
7255    # set URL to load an XML document from the URL.
7256    #   BSTR arg0 --- p [OUT]
7257    def url
7258      OLEProperty.new(@dispatch, 65641, [VT_BYREF|VT_BSTR], [VT_BYREF|VT_BSTR, VT_HRESULT])
7259    end
7260  
7261    # HRESULT readyState
7262    # get ready state.
7263    #   I4 arg0 --- pl [OUT]
7264    def readyState
7265      OLEProperty.new(@dispatch, 65643, [VT_BYREF|VT_I4], [VT_BYREF|VT_I4, VT_HRESULT])
7266    end
7267  
7268    # HRESULT charset
7269    # get encoding.
7270    #   BSTR arg0 --- p [OUT]
7271    def charset
7272      OLEProperty.new(@dispatch, 65645, [VT_BYREF|VT_BSTR], [VT_BYREF|VT_BSTR, VT_HRESULT])
7273    end
7274  
7275    # HRESULT version
7276    # get XML version number.
7277    #   BSTR arg0 --- p [OUT]
7278    def version
7279      OLEProperty.new(@dispatch, 65646, [VT_BYREF|VT_BSTR], [VT_BYREF|VT_BSTR, VT_HRESULT])
7280    end
7281  
7282    # HRESULT doctype
7283    # get document type.
7284    #   BSTR arg0 --- p [OUT]
7285    def doctype
7286      OLEProperty.new(@dispatch, 65647, [VT_BYREF|VT_BSTR], [VT_BYREF|VT_BSTR, VT_HRESULT])
7287    end
7288  
7289    # HRESULT async
7290    # get asynchronous loading flag.
7291    #   BOOL arg0 --- pf [OUT]
7292    def async
7293      OLEProperty.new(@dispatch, 65649, [VT_BYREF|VT_BOOL], [VT_BYREF|VT_BOOL, VT_HRESULT])
7294    end
7295  
7296    # HRESULT createElement
7297    # create different types of IXMLElements.
7298    #   VARIANT arg0 --- vType [IN]
7299    #   VARIANT arg1 --- var1 [IN]
7300    #   IXMLElement2,IXMLElement2 arg2 --- ppElem [OUT]
7301    def createElement(arg0, arg1=nil, arg2=nil)
7302      ret = @dispatch._invoke(65644, [arg0, arg1, arg2], [VT_VARIANT, VT_VARIANT, VT_BYREF|VT_BYREF|VT_DISPATCH])
7303      @lastargs = WIN32OLE::ARGV
7304      ret
7305    end
7306  end