smparkes-johnson 1.1.2.3

data/vendor/tracemonkey/xpconnect/tests/idispatch/COM/XPCIDispatchTest.idl

@@ -0,0 +1,454 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ * ***** BEGIN LICENSE BLOCK *****
+ * Version: MPL 1.1/GPL 2.0/LGPL 2.1
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ *
+ * The Original Code is the IDispatch implementation for XPConnect.
+ *
+ * The Initial Developer of the Original Code is
+ * David Bradley.
+ * Portions created by the Initial Developer are Copyright (C) 2002
+ * the Initial Developer. All Rights Reserved.
+ *
+ * Contributor(s):
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * either the GNU General Public License Version 2 or later (the "GPL"), or
+ * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
+ * in which case the provisions of the GPL or the LGPL are applicable instead
+ * of those above. If you wish to allow use of your version of this file only
+ * under the terms of either the GPL or the LGPL, and not to allow others to
+ * use your version of this file under the terms of the MPL, indicate your
+ * decision by deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL or the LGPL. If you do not delete
+ * the provisions above, a recipient may use your version of this file under
+ * the terms of any one of the MPL, the GPL or the LGPL.
+ *
+ * ***** END LICENSE BLOCK ***** */
+
+// XPCIDispatchTest.idl : IDL source for XPCIDispatchTest.dll
+//
+
+// This file will be processed by the MIDL tool to
+// produce the type library (XPCIDispatchTest.tlb) and marshalling code.
+
+import "oaidl.idl";
+import "ocidl.idl";
+import "objsafe.idl";
+
+[
+    uuid(83A51226-F49D-488A-8F78-75BB2F927F4C),
+    version(1.0),
+    helpstring("XPCIDispatchTest 1.0 Type Library")
+]
+library IDispatchTestLib
+{
+    importlib("stdole32.tlb");
+    importlib("stdole2.tlb");
+
+    [
+        object,
+        uuid(0de5dbae-1d78-45cb-91a2-24516fef2837),
+        dual,
+        helpstring("nsIXPCDispSimple interface"),
+        pointer_default(unique)
+    ]
+    interface nsIXPCDispSimple : IDispatch
+    {
+        [id(1), helpstring("Simple method returning the name of the class")]
+            HRESULT ClassName([out]BSTR * name);
+        [propget, id(2), helpstring("Simple number property")]
+            HRESULT Number([out, retval]long * result);
+        [propput, id(2), helpstring("Simple number property")]
+            HRESULT Number([in]long result);
+    }
+    [
+        uuid(9F39237C-D179-4260-8EF3-4B6D4D7D5570),
+        helpstring("nsXPCDispSimple Class")
+    ]
+    coclass nsXPCDispSimple
+    {
+        [default] interface nsIXPCDispSimple;
+    };
+    [
+        object,
+        uuid(47bf6c99-a30c-4105-8af6-de76dcfdd6dd),
+        dual,
+        helpstring("nsIXPCDispTestMethods interface"),
+        pointer_default(unique)
+    ]
+    interface nsIXPCDispTestMethods : IDispatch
+    {
+        /* Return values test */
+        [id(1), helpstring("method with no parameters")]
+            HRESULT NoParameters();
+        [id(2), helpstring("method that returns a string")]
+            HRESULT ReturnBSTR([out, retval]BSTR * result);
+        [id(3), helpstring("method that returns a 32 bit signed integer")]
+            HRESULT ReturnI4([out, retval]int * result);
+        [id(4), helpstring("method that returns an 8 bit unsigned integer")]
+            HRESULT ReturnUI1([out, retval]unsigned char * result);
+        [id(5), helpstring("method that returns a 16 bit signed integer")]
+            HRESULT ReturnI2([out, retval]short * result);
+        [id(6), helpstring("method that returns a 32 bit floating point number")]
+            HRESULT ReturnR4([out, retval]float * result);
+        [id(7), helpstring("method that returns a 64 bit floating point number")]
+            HRESULT ReturnR8([out, retval]double * result);
+        [id(8), helpstring("method that returns a boolean")]
+            HRESULT ReturnBool([out, retval]VARIANT_BOOL * result);
+        [id(9), helpstring("method that returns an IDispatch pointer")]
+            HRESULT ReturnIDispatch([out, retval]IDispatch ** result);
+        [id(10), helpstring("method that returns an error")]
+            HRESULT ReturnError([out, retval]SCODE * result);
+        [id(12), helpstring("method that returns a date")]
+            HRESULT ReturnDate([out, retval]DATE * result);
+        [id(13), helpstring("method that returns an IUnknown")]
+            HRESULT ReturnIUnknown([out, retval]IUnknown ** result);
+        [id(14), helpstring("method that returns a signed 8 bit integer")]
+            HRESULT ReturnI1([out, retval]char * result);
+        [id(15), helpstring("method that returns an unsigned 16 bit integer")]
+            HRESULT ReturnUI2([out, retval]unsigned short * result);
+        [id(16), helpstring("method that returns an unsigned 32 bit integer")]
+            HRESULT ReturnUI4([out, retval]unsigned long * result);
+        [id(17), helpstring("method that returns an integer")]
+            HRESULT ReturnInt([out, retval]int * result);
+        [id(18), helpstring("method that returns an unsigned integer")]
+            HRESULT ReturnUInt([out, retval]unsigned int * result);
+
+        /* Single input parameter tests */
+        [id(19), helpstring("method that takes a string")]
+            HRESULT TakesBSTR([in]BSTR result);
+        [id(20), helpstring("method that takes a 32 bit signed integer")]
+            HRESULT TakesI4([in]int result);
+        [id(21), helpstring("method that takes an 8 bit unsigned integer")]
+            HRESULT TakesUI1([in]unsigned char result);
+        [id(22), helpstring("method that takes a 16 bit signed integer")]
+            HRESULT TakesI2([in]short result);
+        [id(23), helpstring("method that takes a 32 bit floating point number")]
+            HRESULT TakesR4([in]float result);
+        [id(24), helpstring("method that takes a 64 bit floating point number")]
+            HRESULT TakesR8([in]double result);
+        [id(25), helpstring("method that takes a boolean")]
+            HRESULT TakesBool([in]VARIANT_BOOL result);
+        [id(26), helpstring("method that takes an IDispatch pointer")]
+            HRESULT TakesIDispatch([in]IDispatch * result);
+        [id(27), helpstring("method that takes an error")]
+            HRESULT TakesError([in]SCODE result);
+        [id(29), helpstring("method that takes a date")]
+            HRESULT TakesDate([in]DATE result);
+        [id(30), helpstring("method that takes an IUnknown")]
+            HRESULT TakesIUnknown([in]IUnknown * result);
+        [id(31), helpstring("method that takes a signed 8 bit integer")]
+            HRESULT TakesI1([in]char result);
+        [id(32), helpstring("method that takes an unsigned 16 bit integer")]
+            HRESULT TakesUI2([in]unsigned short result);
+        [id(33), helpstring("method that takes an unsigned 32 bit integer")]
+            HRESULT TakesUI4([in]unsigned long result);
+        [id(34), helpstring("method that takes an integer")]
+            HRESULT TakesInt([in]int result);
+        [id(35), helpstring("method that takes an unsigned integer")]
+            HRESULT TakesUInt([in]unsigned int result);
+
+        /* output parameter tests */
+        [id(36), helpstring("method that outputs a string")]
+            HRESULT OutputsBSTR([out]BSTR * result);
+        [id(37), helpstring("method that outputs a 32 bit signed integer")]
+            HRESULT OutputsI4([out]long * result);
+        [id(38), helpstring("method that outputs an 8 bit unsigned integer")]
+            HRESULT OutputsUI1([out]unsigned char * result);
+        [id(39), helpstring("method that outputs a 16 bit signed integer")]
+            HRESULT OutputsI2([out]short * result);
+        [id(40), helpstring("method that outputs a 32 bit floating point number")]
+            HRESULT OutputsR4([out]float * result);
+        [id(41), helpstring("method that outputs a 64 bit floating point number")]
+            HRESULT OutputsR8([out]double * result);
+        [id(42), helpstring("method that outputs a boolean")]
+            HRESULT OutputsBool([out]VARIANT_BOOL * result);
+        [id(43), helpstring("method that outputs an IDispatch pointer")]
+            HRESULT OutputsIDispatch([out]IDispatch ** result);
+        [id(44), helpstring("method that outputs an error")]
+            HRESULT OutputsError([out]SCODE * result);
+        [id(46), helpstring("method that outputs a date")]
+            HRESULT OutputsDate([out]DATE * result);
+        [id(47), helpstring("method that outputs an IUnknown")]
+            HRESULT OutputsIUnknown([out]IUnknown ** result);
+        [id(48), helpstring("method that outputs a signed 8 bit integer")]
+            HRESULT OutputsI1([out]char * result);
+        [id(49), helpstring("method that outputs an unsigned 16 bit integer")]
+            HRESULT OutputsUI2([out]unsigned short * result);
+        [id(50), helpstring("method that outputs an unsigned 32 bit integer")]
+            HRESULT OutputsUI4([out]unsigned long * result);
+    
+        /* in/outparameter tests */
+        [id(53), helpstring("method that in/outs a string")]
+            HRESULT InOutsBSTR([in, out]BSTR * result);
+        [id(54), helpstring("method that in/outs a 32 bit signed integer")]
+            HRESULT InOutsI4([in, out]long * result);
+        [id(55), helpstring("method that in/outs an 8 bit unsigned integer")]
+            HRESULT InOutsUI1([in, out]unsigned char * result);
+        [id(56), helpstring("method that in/outs a 16 bit signed integer")]
+            HRESULT InOutsI2([in, out]short * result);
+        [id(57), helpstring("method that in/outs a 32 bit floating point number")]
+            HRESULT InOutsR4([in, out]float * result);
+        [id(58), helpstring("method that in/outs a 64 bit floating point number")]
+            HRESULT InOutsR8([in, out]double * result);
+        [id(59), helpstring("method that in/outs a boolean")]
+            HRESULT InOutsBool([in, out]VARIANT_BOOL * result);
+        [id(60), helpstring("method that in/outs an IDispatch pointer")]
+            HRESULT InOutsIDispatch([in, out]IDispatch ** result);
+        [id(61), helpstring("method that in/outs an error")]
+            HRESULT InOutsError([in, out]SCODE * result);
+        [id(63), helpstring("method that in/outs a date")]
+            HRESULT InOutsDate([in, out]DATE * result);
+        [id(64), helpstring("method that in/outs an IUnknown")]
+            HRESULT InOutsIUnknown([in, out]IUnknown ** result);
+        [id(65), helpstring("method that in/outs a signed 8 bit integer")]
+            HRESULT InOutsI1([in, out]char * result);
+        [id(66), helpstring("method that in/outs an unsigned 16 bit integer")]
+            HRESULT InOutsUI2([in, out]unsigned short * result);
+        [id(67), helpstring("method that in/outs an unsigned 32 bit integer")]
+            HRESULT InOutsUI4([in, out]unsigned long * result);
+
+        /* input and return tests*/
+        [id(70), helpstring("method that takes an long and returns it")]
+            HRESULT OneParameterWithReturn([in]long input, [out,retval]long* result);
+        [id(71), helpstring("method that takes a string and returns it")]
+            HRESULT StringInputAndReturn([in]BSTR str, [out, retval]BSTR* result);
+        [id(72), helpstring("method that takes an IDispatch and returns it")]
+            HRESULT IDispatchInputAndReturn([in]IDispatch* input, [out,retval]IDispatch** result);
+    
+        /* Multiple parameters */
+        [id(73), helpstring("method that takes two parameters")]
+            HRESULT TwoParameters([in]long one, [in]long two);
+        [id(74), helpstring("method that takes 12 input parameters")]
+            HRESULT TwelveInParameters([in]long one, [in]long two, [in]long three, 
+                                       [in]long four, [in]long five, [in]long six,
+                                       [in]long seven, [in]long eight, 
+                                       [in]long nine, [in]long ten,
+                                       [in]long eleven, [in]long twelve);
+        [id(75), helpstring("method that takes 12 out parameters")]
+            HRESULT TwelveOutParameters([out]long *one, [out]long *two,
+                                        [out]long *three, [out]long *four,
+                                        [out]long *five, [out]long *six,
+                                        [out]long *seven, [out]long *eight,
+                                        [out]long *nine, [out]long *ten,
+                                        [out]long *eleven, [out]long *twelve);
+        [id(76), helpstring("method that takes 12 input string parameters")]
+            HRESULT TwelveStrings([in]BSTR one, [in]BSTR two, [in]BSTR three,
+                                 [in]BSTR four, [in]BSTR five, [in]BSTR six,
+                                 [in]BSTR seven, [in]BSTR eight, [in]BSTR nine,
+                                 [in]BSTR ten, [in]BSTR eleven, [in]BSTR twelve);
+        [id(77), helpstring("method that takes 12 input string parameters")]
+            HRESULT TwelveOutStrings([out]BSTR* one, [out]BSTR* two,
+                                     [out]BSTR* three, [out]BSTR* four,
+                                     [out]BSTR* five, [out]BSTR* six,
+                                     [out]BSTR* seven, [out]BSTR* eight,
+                                     [out]BSTR* nine, [out]BSTR* ten,
+                                     [out]BSTR* eleven, [out]BSTR* twelve);
+        [id(78), helpstring("method that takes 12 input string parameters")]
+            HRESULT TwelveIDispatch([in]IDispatch* one, [in]IDispatch* two,
+                                    [in]IDispatch* three, [in]IDispatch* four,
+                                    [in]IDispatch* five, [in]IDispatch* six,
+                                    [in]IDispatch* seven, [in]IDispatch* eight,
+                                    [in]IDispatch* nine, [in]IDispatch* ten,
+                                    [in]IDispatch* eleven,
+                                    [in]IDispatch* twelve);
+        [id(79), helpstring("method that takes 12 input string parameters")]
+            HRESULT TwelveOutIDispatch([out]IDispatch** one,
+                                       [out]IDispatch** two,
+                                       [out]IDispatch** three,
+                                       [out]IDispatch** four,
+                                       [out]IDispatch** five,
+                                       [out]IDispatch** six,
+                                       [out]IDispatch** seven,
+                                       [out]IDispatch** eight,
+                                       [out]IDispatch** nine,
+                                       [out]IDispatch** ten,
+                                       [out]IDispatch** eleven,
+                                       [out]IDispatch** twelve);
+        [id(80), helpstring("method that generates an error")]
+            HRESULT CreateError();
+    }
+    [
+        uuid(745D1149-9F46-418C-B176-71EAA98974BA),
+        helpstring("nsXPCDispTestMethods Class")
+    ]
+    coclass nsXPCDispTestMethods
+    {
+        [default] interface nsIXPCDispTestMethods;
+    };
+    [
+        object,
+        uuid(f876c083-ae00-4b78-93b8-8305980f0864),
+        dual,
+        helpstring("nsIXPCDispTestArrays interface"),
+        pointer_default(unique)
+    ]
+    interface nsIXPCDispTestArrays : IDispatch
+    {
+        [id(1), helpstring("returns a SAFEARRAY")]
+            HRESULT ReturnSafeArray([out, retval]SAFEARRAY(VARIANT)* result);
+        [id(2), helpstring("returns a SAFEARRAY")]
+            HRESULT ReturnSafeArrayBSTR([out, retval]SAFEARRAY(VARIANT)* result);
+        [id(3), helpstring("returns a SAFEARRAY")]
+            HRESULT ReturnSafeArrayIDispatch([out, retval]SAFEARRAY(VARIANT)* result);
+        [id(4), helpstring("method that takes a SAFEARRAY")]
+            HRESULT TakesSafeArray([in]SAFEARRAY(VARIANT) array);
+        [id(5), helpstring("method that takes a SAFEARRAY")]
+            HRESULT TakesSafeArrayBSTR([in]SAFEARRAY(VARIANT) array);
+        [id(6), helpstring("method that takes a SAFEARRAY")]
+            HRESULT TakesSafeArrayIDispatch([in]SAFEARRAY(VARIANT) array);
+        [id(7), helpstring("method that takes a SAFEARRAY")]
+            HRESULT InOutSafeArray([in, out]SAFEARRAY(VARIANT) * array);
+        [id(8), helpstring("method that takes a SAFEARRAY")]
+            HRESULT InOutSafeArrayBSTR([in, out]SAFEARRAY(VARIANT) * array);
+        [id(9), helpstring("method that takes a SAFEARRAY")]
+            HRESULT InOutSafeArrayIDispatch([in, out]SAFEARRAY(VARIANT) * array);
+    }
+    [
+        uuid(AB085C43-C619-48C8-B68C-C495BDE12DFB),
+        helpstring("nsXPCDispTestArrays Class")
+    ]
+    coclass nsXPCDispTestArrays
+    {
+        [default] interface nsIXPCDispTestArrays;
+    };
+    [
+        object,
+        uuid(9782107f-14cc-40b2-b0cd-988d81a46e9e),
+        dual,
+        helpstring("nsIXPCDispTestNoIDispatch interface"),
+        pointer_default(unique)
+    ]
+    interface nsIXPCDispTestNoIDispatch : IUnknown
+    {
+    }
+    [
+        uuid(7414404F-A4CC-4E3C-9B32-BB20CB22F541),
+        helpstring("nsXPCDispTestNoIDispatch Class")
+    ]
+    coclass nsXPCDispTestNoIDispatch
+    {
+        [default] interface nsIXPCDispTestNoIDispatch;
+    };
+    [
+        object,
+        uuid(7830CACE-5019-489D-8B69-029E70CF39B7),
+        dual,
+        helpstring("nsIXPCDispTestProperties Interface"),
+        pointer_default(unique)
+    ]
+    interface nsIXPCDispTestProperties : IDispatch
+    {
+        [propget, id(1), helpstring("property Short")] HRESULT Short([out, retval] short *pVal);
+        [propput, id(1), helpstring("property Short")] HRESULT Short([in] short newVal);
+        [propget, id(2), helpstring("property Long")] HRESULT Long([out, retval] long *pVal);
+        [propput, id(2), helpstring("property Long")] HRESULT Long([in] long newVal);
+        [propget, id(3), helpstring("property Float")] HRESULT Float([out, retval] float *pVal);
+        [propput, id(3), helpstring("property Float")] HRESULT Float([in] float newVal);
+        [propget, id(4), helpstring("property Double")] HRESULT Double([out, retval] double *pVal);
+        [propput, id(4), helpstring("property Double")] HRESULT Double([in] double newVal);
+        [propget, id(5), helpstring("property Currency")] HRESULT Currency([out, retval] CURRENCY *pVal);
+        [propput, id(5), helpstring("property Currency")] HRESULT Currency([in] CURRENCY newVal);
+        [propget, id(6), helpstring("property Date")] HRESULT Date([out, retval] DATE *pVal);
+        [propput, id(6), helpstring("property Date")] HRESULT Date([in] DATE newVal);
+        [propget, id(7), helpstring("property String")] HRESULT String([out, retval] BSTR *pVal);
+        [propput, id(7), helpstring("property String")] HRESULT String([in] BSTR newVal);
+        [propget, id(8), helpstring("property DispatchPtr")] HRESULT DispatchPtr([out, retval] IDispatch* *pVal);
+        [propput, id(8), helpstring("property DispatchPtr")] HRESULT DispatchPtr([in] IDispatch* newVal);
+        [propget, id(9), helpstring("property SCode")] HRESULT SCode([out, retval] SCODE *pVal);
+        [propput, id(9), helpstring("property SCode")] HRESULT SCode([in] SCODE newVal);
+        [propget, id(10), helpstring("property Boolean")] HRESULT Boolean([out, retval] BOOL *pVal);
+        [propput, id(10), helpstring("property Boolean")] HRESULT Boolean([in] BOOL newVal);
+        [propget, id(11), helpstring("property Variant")] HRESULT Variant([out, retval] VARIANT *pVal);
+        [propput, id(11), helpstring("property Variant")] HRESULT Variant([in] VARIANT newVal);
+        [propget, id(12), helpstring("property COMPtr")] HRESULT COMPtr([out, retval] IUnknown* *pVal);
+        [propput, id(12), helpstring("property COMPtr")] HRESULT COMPtr([in] IUnknown* newVal);
+        [propget, id(13), helpstring("property Char")] HRESULT Char([out, retval] unsigned char *pVal);
+        [propput, id(13), helpstring("property Char")] HRESULT Char([in] unsigned char newVal);
+		[propget, id(14), helpstring("property ParameterizedProperty")] HRESULT ParameterizedProperty([in]long aIndex, [out, retval] long *pVal);
+		[propput, id(14), helpstring("property ParameterizedProperty")] HRESULT ParameterizedProperty([in]long aIndex, [in] long newVal);
+		[propget, id(15), helpstring("property ParameterizedPropertyCount")] HRESULT ParameterizedPropertyCount([out, retval] long *pVal);
+    };
+    
+    [
+        object,
+        uuid(0797788A-CB08-4995-BD45-7BF8C468DE21),
+        dual,
+        helpstring("nsIXPCDispTestScriptOn Interface"),
+        pointer_default(unique)
+    ]
+    interface nsIXPCDispTestScriptOn : IDispatch
+    {
+    };
+    
+    [
+        uuid(2A06373F-3E61-4882-A3D7-A104F70B09ED),
+        helpstring("nsXPCDispTestScriptOn Class")
+    ]
+    coclass nsXPCDispTestScriptOn
+    {
+        [default] interface nsIXPCDispTestScriptOn;
+    };
+
+    [
+        object,
+        uuid(EE6F9DB5-890F-422D-B9DC-9C5AB5A1D654),
+        dual,
+        helpstring("nsIXPCDispTestScriptOff Interface"),
+        pointer_default(unique)
+    ]
+    interface nsIXPCDispTestScriptOff : IDispatch
+    {
+    };
+	
+	[
+		object,
+		uuid(D84352CA-1A01-4E72-9072-77AFA669B3AD),
+		dual,
+		helpstring("nsIXPCDispTestWrappedJS Interface"),
+		pointer_default(unique)
+	]
+	interface nsIXPCDispTestWrappedJS : IDispatch
+	{
+		[id(1), helpstring("method TestParamTypes")] HRESULT TestParamTypes([in] IDispatch * obj, [out, retval]BSTR * errMsg);
+	};
+    
+	[
+		uuid(EAEE6BB2-C005-4B91-BCA7-6613236F6F69),
+		helpstring("nsXPCDispTestWrappedJS Class")
+	]
+	coclass nsXPCDispTestWrappedJS
+	{
+		[default] interface nsIXPCDispTestWrappedJS;
+	};
+
+    [
+        uuid(959CD122-9826-4757-BA09-DE327D55F9E7),
+        helpstring("nsXPCDispTestScriptOff Class")
+    ]
+    coclass nsXPCDispTestScriptOff
+    {
+        [default] interface nsIXPCDispTestScriptOff;
+    };
+
+    [
+        uuid(D8B4265B-1768-4CA9-A285-7CCAEEB51C74),
+        helpstring("nsXPCDispTestProperties Class")
+    ]
+    coclass nsXPCDispTestProperties
+    {
+        [default] interface nsIXPCDispTestProperties;
+    };
+
+    
+};

data/vendor/tracemonkey/xpconnect/tests/idispatch/COM/XPCIDispatchTest.rc

@@ -0,0 +1,145 @@
+//Microsoft Developer Studio generated resource script.
+//
+#include "resource.h"
+
+#define APSTUDIO_READONLY_SYMBOLS
+/////////////////////////////////////////////////////////////////////////////
+//
+// Generated from the TEXTINCLUDE 2 resource.
+//
+#include "winres.h"
+
+/////////////////////////////////////////////////////////////////////////////
+#undef APSTUDIO_READONLY_SYMBOLS
+
+/////////////////////////////////////////////////////////////////////////////
+// English (U.S.) resources
+
+#if !defined(AFX_RESOURCE_DLL) || defined(AFX_TARG_ENU)
+#ifdef _WIN32
+LANGUAGE LANG_ENGLISH, SUBLANG_ENGLISH_US
+#pragma code_page(1252)
+#endif //_WIN32
+
+#ifdef APSTUDIO_INVOKED
+/////////////////////////////////////////////////////////////////////////////
+//
+// TEXTINCLUDE
+//
+
+1 TEXTINCLUDE DISCARDABLE 
+BEGIN
+    "resource.h\0"
+END
+
+2 TEXTINCLUDE DISCARDABLE 
+BEGIN
+    "#include ""winres.h""\r\n"
+    "\0"
+END
+
+3 TEXTINCLUDE DISCARDABLE 
+BEGIN
+    "1 TYPELIB ""XPCIDispatchTest.tlb""\r\n"
+    "\0"
+END
+
+#endif    // APSTUDIO_INVOKED
+
+
+#ifndef _MAC
+/////////////////////////////////////////////////////////////////////////////
+//
+// Version
+//
+
+VS_VERSION_INFO VERSIONINFO
+ FILEVERSION 1,0,0,1
+ PRODUCTVERSION 1,0,0,1
+ FILEFLAGSMASK 0x3fL
+#ifdef _DEBUG
+ FILEFLAGS 0x1L
+#else
+ FILEFLAGS 0x0L
+#endif
+ FILEOS 0x4L
+ FILETYPE 0x2L
+ FILESUBTYPE 0x0L
+BEGIN
+    BLOCK "StringFileInfo"
+    BEGIN
+        BLOCK "040904B0"
+        BEGIN
+            VALUE "CompanyName", "\0"
+            VALUE "FileDescription", "XPCIDispatchTest Module\0"
+            VALUE "FileVersion", "1, 0, 0, 1\0"
+            VALUE "InternalName", "XPCIDispatchTest\0"
+            VALUE "LegalCopyright", "Copyright 2002\0"
+            VALUE "OriginalFilename", "XPCIDispatchTest.DLL\0"
+            VALUE "ProductName", "XPCIDispatchTest Module\0"
+            VALUE "ProductVersion", "1, 0, 0, 1\0"
+            VALUE "OLESelfRegister", "\0"
+        END
+    END
+    BLOCK "VarFileInfo"
+    BEGIN
+        VALUE "Translation", 0x409, 1200
+    END
+END
+
+#endif    // !_MAC
+
+
+/////////////////////////////////////////////////////////////////////////////
+//
+// REGISTRY
+//
+
+IDR_nsXPCDispTestMethods REGISTRY DISCARDABLE    "nsXPCDispTestMethods.rgs"
+IDR_nsXPCDispSimple     REGISTRY DISCARDABLE    "nsXPCDispSimple.rgs"
+IDR_nsXPCDispTestNoIDispatch REGISTRY DISCARDABLE    "nsXPCDispTestNoIDispatch.rgs"
+IDR_nsXPCDispTestProperties REGISTRY DISCARDABLE    "nsXPCDispTestProperties.rgs"
+IDR_nsXPCDispTestArrays REGISTRY DISCARDABLE    "nsXPCDispTestArrays.rgs"
+IDR_nsXPCDispTestScriptOn REGISTRY DISCARDABLE    "nsXPCDispTestScriptOn.rgs"
+IDR_nsXPCDispTestScriptOff REGISTRY DISCARDABLE    "nsXPCDispTestScriptOff.rgs"
+IDR_nsXPCDispTestWrappedJS REGISTRY DISCARDABLE    "nsXPCDispTestWrappedJS.rgs"
+
+/////////////////////////////////////////////////////////////////////////////
+//
+// String Table
+//
+
+STRINGTABLE DISCARDABLE 
+BEGIN
+    IDS_PROJNAME            "XPCIDispatchTest"
+    IDS_NSXPCDISPTTESTMETHODS_DESC "nsXPCDisptTestMethods Class"
+    IDS_NSXPCDISPTESTMETHODS_DESC "nsXPCDispTestMethods Class"
+    IDS_NSXPCDISPSIMPLE_DESC "nsXPCDispSimple Class"
+    IDS_NSXPCDISPTESTNOIDISPATCH_DESC "nsXPCDispTestNoIDispatch Class"
+    IDS_NSXPCDISPTESTNOSCRIPT_DESC "nsXPCDispTestNoScript Class"
+    IDS_NSXPCDISPTESTPROPERTIES_DESC "nsXPCDispTestProperties Class"
+END
+
+STRINGTABLE DISCARDABLE 
+BEGIN
+    IDS_NSXPCDISPTESTARRAYS_DESC "nsXPCDispTestArrays Class"
+    IDS_NSXPCDISPTESTSCRIPTON_DESC "nsXPCDispTestScriptOn Class"
+    IDS_NSXPCDISPTESTSCRIPTOFF_DESC "nsXPCDispTestScriptOff Class"
+    IDS_NSXPCDISPTESTWRAPPEDJS_DESC "nsXPCDispTestWrappedJS Class"
+END
+
+#endif    // English (U.S.) resources
+/////////////////////////////////////////////////////////////////////////////
+
+
+
+#ifndef APSTUDIO_INVOKED
+/////////////////////////////////////////////////////////////////////////////
+//
+// Generated from the TEXTINCLUDE 3 resource.
+//
+1 TYPELIB "XPCIDispatchTest.tlb"
+
+/////////////////////////////////////////////////////////////////////////////
+#endif    // not APSTUDIO_INVOKED
+

data/vendor/tracemonkey/xpconnect/tests/idispatch/COM/nsXPCDispSimple.cpp

@@ -0,0 +1,44 @@
+// nsXPCDispSimple.cpp : Implementation of CXPCIDispatchTestApp and DLL registration.
+
+#include "stdafx.h"
+#include "XPCIDispatchTest.h"
+#include "nsXPCDispSimple.h"
+
+/////////////////////////////////////////////////////////////////////////////
+//
+
+STDMETHODIMP nsXPCDispSimple::InterfaceSupportsErrorInfo(REFIID riid)
+{
+    static const IID* arr[] = 
+    {
+        &IID_nsIXPCDispSimple,
+    };
+
+    for (int i=0;i<sizeof(arr)/sizeof(arr[0]);i++)
+    {
+        if (InlineIsEqualGUID(*arr[i],riid))
+            return S_OK;
+    }
+    return S_FALSE;
+}
+
+STDMETHODIMP nsXPCDispSimple::ClassName(BSTR * name)
+{
+    if (name == NULL)
+        return E_POINTER;
+    CComBSTR x("nsXPCDispSimple");
+    *name = x.Detach();
+    return S_OK;
+}
+STDMETHODIMP nsXPCDispSimple::get_Number(LONG * result)
+{
+    if (result == NULL)
+        return E_POINTER;
+    *result = mNumber;
+    return S_OK;
+}
+STDMETHODIMP nsXPCDispSimple::put_Number(LONG result)
+{
+    mNumber = result;
+    return S_OK;
+}