pjs/xpcom/sample/nsSample.js

132 строки
5.0 KiB
JavaScript
Исходник Обычный вид История

1999-09-22 01:11:29 +04:00
/* -*- 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? */ }
1999-09-22 01:11:29 +04:00
/* 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.
*/
2000-06-14 08:46:22 +04:00
get value() { return this.val; },
set value(newval) { return this.val = newval; },
1999-09-22 01:11:29 +04:00
writeValue: function (aPrefix) {
dump("mySample::writeValue => " + aPrefix + this.val + "\n");
},
poke: function (aValue) { this.val = aValue; },
/*
* Note that until bug 14460 is resolved, you need to name the method
* QueryInterface, not queryInterface as you might expect given the
* interCaps naming convention used in most XPIDL.
*/
QueryInterface: function (iid) {
if (!iid.equals(Components.interfaces.nsISample) &&
!iid.equals(Components.interfaces.nsISupports)) {
throw Components.results.NS_ERROR_NO_INTERFACE;
}
return this;
},
val: "<default value>"
1999-09-22 01:11:29 +04:00
}
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) {
dump("*** Deferring registration of sample JS components\n");
this.firstTime = false;
throw Components.results.NS_ERROR_FACTORY_REGISTER_AGAIN;
}
dump("*** Registering sample JS components\n");
compMgr.registerComponentWithType(this.myCID,
"Sample JS Component",
this.myProgID, fileSpec,
location, true, true,
type);
1999-09-22 01:11:29 +04:00
},
/*
* The GetClassObject method is responsible for producing Factory and
* SingletonFactory objects (the latter are specialized for services).
*/
getClassObject: function (compMgr, cid, iid) {
if (!cid.equals(this.myCID))
1999-09-22 01:11:29 +04:00
throw Components.results.NS_ERROR_NO_INTERFACE;
if (!iid.equals(Components.interfaces.nsIFactory))
throw Components.results.NS_ERROR_NOT_IMPLEMENTED;
return this.myFactory;
1999-09-22 01:11:29 +04:00
},
/* CID for this class */
myCID: Components.ID("{dea98e50-1dd1-11b2-9344-8902b4805a2e}"),
1999-09-22 01:11:29 +04:00
/* ProgID for this class */
myProgID: "@mozilla.org/jssample;1",
1999-09-22 01:11:29 +04:00
/* 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) {
dump("CI: " + iid + "\n");
if (outer != null)
1999-09-22 01:11:29 +04:00
throw Components.results.NS_ERROR_NO_AGGREGATION;
return (new mySample()).QueryInterface(iid);
1999-09-22 01:11:29 +04:00
}
},
/*
* 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) {
dump("*** Unloading sample JS components\n");
return true;
1999-09-22 01:11:29 +04:00
}
};
1999-09-22 01:11:29 +04:00
function NSGetModule(compMgr, fileSpec) {
return myModule;
}