diff options
author | Daniel Baumann <daniel.baumann@progress-linux.org> | 2024-04-07 16:49:04 +0000 |
---|---|---|
committer | Daniel Baumann <daniel.baumann@progress-linux.org> | 2024-04-07 16:49:04 +0000 |
commit | 16f504a9dca3fe3b70568f67b7d41241ae485288 (patch) | |
tree | c60f36ada0496ba928b7161059ba5ab1ab224f9d /src/libs/xpcom18a4/xpcom/sample/nsSample.js | |
parent | Initial commit. (diff) | |
download | virtualbox-16f504a9dca3fe3b70568f67b7d41241ae485288.tar.xz virtualbox-16f504a9dca3fe3b70568f67b7d41241ae485288.zip |
Adding upstream version 7.0.6-dfsg.upstream/7.0.6-dfsgupstream
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'src/libs/xpcom18a4/xpcom/sample/nsSample.js')
-rw-r--r-- | src/libs/xpcom18a4/xpcom/sample/nsSample.js | 130 |
1 files changed, 130 insertions, 0 deletions
diff --git a/src/libs/xpcom18a4/xpcom/sample/nsSample.js b/src/libs/xpcom18a4/xpcom/sample/nsSample.js new file mode 100644 index 00000000..1cc9a091 --- /dev/null +++ b/src/libs/xpcom18a4/xpcom/sample/nsSample.js @@ -0,0 +1,130 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ + +/* + * No magic constructor behaviour, as is de rigeur for XPCOM. + * If you must perform some initialization, and it could possibly fail (even + * due to an out-of-memory condition), you should use an Init method, which + * can convey failure appropriately (thrown exception in JS, + * NS_FAILED(nsresult) return in C++). + * + * In JS, you can actually cheat, because a thrown exception will cause the + * CreateInstance call to fail in turn, but not all languages are so lucky. + * (Though ANSI C++ provides exceptions, they are verboten in Mozilla code + * for portability reasons -- and even when you're building completely + * platform-specific code, you can't throw across an XPCOM method boundary.) + */ +function mySample() { /* big comment for no code, eh? */ } + +/* decorate prototype to provide ``class'' methods and property accessors */ +mySample.prototype = { + /* + * get and set are new Magic in JS1.5, borrowing the intent -- if not + * the exact syntax -- from the JS2 design. They define accessors for + * properties on the JS object, follow the expected rules for prototype + * delegation, and make a mean cup of coffee. + */ + get value() { return this.val; }, + set value(newval) { return this.val = newval; }, + + writeValue: function (aPrefix) { + debug("mySample::writeValue => " + aPrefix + this.val + "\n"); + }, + poke: function (aValue) { this.val = aValue; }, + + QueryInterface: function (iid) { + if (iid.equals(Components.interfaces.nsISample) || + iid.equals(Components.interfaces.nsISupports)) + return this; + + Components.returnCode = Components.results.NS_ERROR_NO_INTERFACE; + return null; + }, + + val: "<default value>" +} + +var myModule = { + firstTime: true, + + /* + * RegisterSelf is called at registration time (component installation + * or the only-until-release startup autoregistration) and is responsible + * for notifying the component manager of all components implemented in + * this module. The fileSpec, location and type parameters are mostly + * opaque, and should be passed on to the registerComponent call + * unmolested. + */ + registerSelf: function (compMgr, fileSpec, location, type) { + if (this.firstTime) { + debug("*** Deferring registration of sample JS components\n"); + this.firstTime = false; + throw Components.results.NS_ERROR_FACTORY_REGISTER_AGAIN; + } + debug("*** Registering sample JS components\n"); + compMgr = compMgr.QueryInterface(Components.interfaces.nsIComponentRegistrar); + compMgr.registerFactoryLocation(this.myCID, + "Sample JS Component", + this.myProgID, + fileSpec, + location, + type); + }, + + /* + * The GetClassObject method is responsible for producing Factory objects + */ + getClassObject: function (compMgr, cid, iid) { + if (!cid.equals(this.myCID)) + throw Components.results.NS_ERROR_NO_INTERFACE; + + if (!iid.equals(Components.interfaces.nsIFactory)) + throw Components.results.NS_ERROR_NOT_IMPLEMENTED; + + return this.myFactory; + }, + + /* CID for this class */ + myCID: Components.ID("{dea98e50-1dd1-11b2-9344-8902b4805a2e}"), + + /* ProgID for this class */ + myProgID: "@mozilla.org/jssample;1", + + /* factory object */ + myFactory: { + /* + * Construct an instance of the interface specified by iid, possibly + * aggregating it with the provided outer. (If you don't know what + * aggregation is all about, you don't need to. It reduces even the + * mightiest of XPCOM warriors to snivelling cowards.) + */ + createInstance: function (outer, iid) { + debug("CI: " + iid + "\n"); + if (outer != null) + throw Components.results.NS_ERROR_NO_AGGREGATION; + + return (new mySample()).QueryInterface(iid); + } + }, + + /* + * The canUnload method signals that the component is about to be unloaded. + * C++ components can return false to indicate that they don't wish to be + * unloaded, but the return value from JS components' canUnload is ignored: + * mark-and-sweep will keep everything around until it's no longer in use, + * making unconditional ``unload'' safe. + * + * You still need to provide a (likely useless) canUnload method, though: + * it's part of the nsIModule interface contract, and the JS loader _will_ + * call it. + */ + canUnload: function(compMgr) { + debug("*** Unloading sample JS components\n"); + return true; + } +}; + +function NSGetModule(compMgr, fileSpec) { + return myModule; +} + + |