home *** CD-ROM | disk | FTP | other *** search
/ Chip 2002 January / 01_02.iso / linux / mozilla-installer_linux / xpi / chatzilla.xpi / bin / components / chatzilla-service.js
Text File  |  2001-11-20  |  11KB  |  347 lines
  1. /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
  2.  * The contents of this file are subject to the Mozilla Public
  3.  * License Version 1.1 (the "License"); you may not use this file
  4.  * except in compliance with the License. You may obtain a copy of
  5.  * the License at http://www.mozilla.org/MPL/
  6.  * 
  7.  * Software distributed under the License is distributed on an "AS
  8.  * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
  9.  * implied. See the License for the specific language governing
  10.  * rights and limitations under the License.
  11.  * 
  12.  * The Original Code is mozilla.org code.
  13.  * 
  14.  * The Initial Developer of the Original Code is Netscape
  15.  * Communications Corporation.  Portions created by Netscape are
  16.  * Copyright (C) 1999 Netscape Communications Corporation.  All
  17.  * Rights Reserved.
  18.  * 
  19.  * Contributor(s): 
  20.  * Seth Spitzer <sspitzer@netscape.com>
  21.  * Robert Ginda <rginda@netscape.com>
  22.  */
  23.  
  24. /*
  25.  * This file contains the following chatzilla related components:
  26.  * 1. Command line handler service, for responding to the -chat command line
  27.  *    option. (CLineHandler)
  28.  * 2. Content handler for responding to content of type x-application-irc
  29.  *    (IRCContentHandler)
  30.  * 3. Protocol handler for supplying a channel to the browser when an irc://
  31.  *    link is clicked. (IRCProtocolHandler)
  32.  * 4. A (nearly empty) imeplementation of nsIChannel for telling the browser
  33.  *    that irc:// links have the content type x-application-irc (BogusChannel)
  34.  */
  35.  
  36. /* components defined in this file */
  37. const CLINE_SERVICE_CONTRACTID =
  38.     "@mozilla.org/commandlinehandler/general-startup;1?type=chat";
  39. const CLINE_SERVICE_CID =
  40.     Components.ID("{38a95514-1dd2-11b2-97e7-9da958640f2c}");
  41. const IRCCNT_HANDLER_CONTRACTID =
  42.     "@mozilla.org/uriloader/content-handler;1?type=x-application-irc";
  43. const IRCCNT_HANDLER_CID =
  44.     Components.ID("{98919a14-1dd1-11b2-be1a-b84344307f0a}");
  45. const IRCPROT_HANDLER_CONTRACTID =
  46.     "@mozilla.org/network/protocol;1?name=irc";
  47. const IRCPROT_HANDLER_CID =
  48.     Components.ID("{f21c35f4-1dd1-11b2-a503-9bf8a539ea39}");
  49.  
  50. /* components used in this file */
  51. const MEDIATOR_CONTRACTID =
  52.     "@mozilla.org/rdf/datasource;1?name=window-mediator"
  53. const SIMPLEURI_CONTRACTID = 
  54.     "@mozilla.org/network/simple-uri;1";
  55. const ASS_CONTRACTID =
  56.     "@mozilla.org/appshell/appShellService;1";
  57.  
  58. /* interafces used in this file */
  59. const nsIWindowMediator  = Components.interfaces.nsIWindowMediator;
  60. const nsICmdLineHandler  = Components.interfaces.nsICmdLineHandler;
  61. const nsICategoryManager = Components.interfaces.nsICategoryManager;
  62. const nsIContentHandler  = Components.interfaces.nsIContentHandler;
  63. const nsIProtocolHandler = Components.interfaces.nsIProtocolHandler;
  64. const nsIURI             = Components.interfaces.nsIURI;
  65. const nsIChannel         = Components.interfaces.nsIChannel;
  66. const nsIRequest         = Components.interfaces.nsIRequest;
  67. const nsIAppShellService = Components.interfaces.nsIAppShellService;
  68. const nsISupports        = Components.interfaces.nsISupports;
  69.  
  70. /* Command Line handler service */
  71. function CLineService()
  72. {}
  73.  
  74. CLineService.prototype.commandLineArgument = "-chat";
  75. CLineService.prototype.prefNameForStartup = "general.startup.chat";
  76. CLineService.prototype.chromeUrlForTask="chrome://chatzilla/content";
  77. CLineService.prototype.helpText = "Start with an IRC chat client";
  78. CLineService.prototype.handlesArgs=false;
  79. CLineService.prototype.defaultArgs ="";
  80. CLineService.prototype.openWindowWithArgs=false;
  81.  
  82. /* factory for command line handler service (CLineService) */
  83. var CLineFactory = new Object();
  84.  
  85. CLineFactory.createInstance =
  86. function (outer, iid) {
  87.     if (outer != null)
  88.         throw Components.results.NS_ERROR_NO_AGGREGATION;
  89.  
  90.     if (!iid.equals(nsICmdLineHandler) && !iid.equals(nsISupports))
  91.         throw Components.results.NS_ERROR_INVALID_ARG;
  92.  
  93.     return new CLineService();
  94. }
  95.  
  96. /* x-application-irc content handler */
  97. function IRCContentHandler ()
  98. {}
  99.  
  100. IRCContentHandler.prototype.QueryInterface =
  101. function (iid) {
  102.  
  103.     if (!iid.equals(nsIContentHandler))
  104.         throw Components.results.NS_ERROR_NO_INTERFACE;
  105.  
  106.     return this;
  107. }
  108.  
  109. IRCContentHandler.prototype.handleContent =
  110. function (aContentType, aCommand, aWindowTarget, aRequest)
  111. {
  112.     var e;
  113.     var channel = aRequest.QueryInterface(nsIChannel);
  114.     
  115.     /*
  116.     dump ("ircLoader.handleContent (" + aContentType + ", " +
  117.           aCommand + ", " + aWindowTarget + ", " + channel.URI.spec + ")\n");
  118.     */
  119.  
  120.     var windowManager =
  121.         Components.classes[MEDIATOR_CONTRACTID].getService(nsIWindowMediator);
  122.  
  123.     var w = windowManager.getMostRecentWindow("irc:chatzilla");
  124.  
  125.     if (w)
  126.     {
  127.         w.focus();
  128.         w.gotoIRCURL(channel.URI.spec);
  129.     }
  130.     else
  131.     {
  132.         var ass =
  133.             Components.classes[ASS_CONTRACTID].getService(nsIAppShellService);
  134.         w = ass.hiddenDOMWindow;
  135.  
  136.         var args = new Object ();
  137.         args.url = channel.URI.spec;
  138.  
  139.         w.openDialog("chrome://chatzilla/content/chatzilla.xul", "_blank",
  140.                      "chrome,menubar,toolbar,resizable,dialog=no", args);
  141.     }
  142.     
  143. }
  144.  
  145. /* content handler factory object (IRCContentHandler) */
  146. var IRCContentHandlerFactory = new Object();
  147.  
  148. IRCContentHandlerFactory.createInstance =
  149. function (outer, iid) {
  150.     if (outer != null)
  151.         throw Components.results.NS_ERROR_NO_AGGREGATION;
  152.  
  153.     if (!iid.equals(nsIContentHandler) && !iid.equals(nsISupports))
  154.         throw Components.results.NS_ERROR_INVALID_ARG;
  155.  
  156.     return new IRCContentHandler();
  157. }
  158.  
  159. /* irc protocol handler component */
  160. function IRCProtocolHandler()
  161. {
  162. }
  163.  
  164. IRCProtocolHandler.prototype.scheme = "irc";
  165. IRCProtocolHandler.prototype.defaultPort = 6667;
  166. IRCProtocolHandler.prototype.protocolFlags = 
  167.                    nsIProtocolHandler.URI_NORELATIVE |
  168.                    nsIProtocolHandler.ALLOWS_PROXY;
  169.  
  170. IRCProtocolHandler.prototype.allowPort =
  171. function (aPort, aScheme)
  172. {
  173.     return false;
  174. }
  175.  
  176. IRCProtocolHandler.prototype.newURI =
  177. function (aSpec, aBaseURI)
  178. {
  179.     if (aBaseURI)
  180.     {
  181.         dump ("-*- ircHandler: aBaseURI passed to newURI, bailing.\n");
  182.         return null;
  183.     }
  184.     
  185.     var uri = Components.classes[SIMPLEURI_CONTRACTID].createInstance(nsIURI);
  186.     uri.spec = aSpec;
  187.     
  188.     return uri;
  189. }
  190.  
  191. IRCProtocolHandler.prototype.newChannel =
  192. function (aURI)
  193. {
  194.     return new BogusChannel (aURI);
  195. }
  196.  
  197. /* protocol handler factory object (IRCProtocolHandler) */
  198. var IRCProtocolHandlerFactory = new Object();
  199.  
  200. IRCProtocolHandlerFactory.createInstance =
  201. function (outer, iid) {
  202.     if (outer != null)
  203.         throw Components.results.NS_ERROR_NO_AGGREGATION;
  204.  
  205.     if (!iid.equals(nsIProtocolHandler) && !iid.equals(nsISupports))
  206.         throw Components.results.NS_ERROR_INVALID_ARG;
  207.  
  208.     return new IRCProtocolHandler();
  209. }
  210.  
  211. /* bogus IRC channel used by the IRCProtocolHandler */
  212. function BogusChannel (aURI)
  213. {
  214.     this.URI = aURI;
  215.     this.originalURI = aURI;
  216. }
  217.  
  218. BogusChannel.prototype.QueryInterface =
  219. function (iid) {
  220.  
  221.     if (!iid.equals(nsIChannel) && !iid.equals(nsIRequest) &&
  222.         !iid.equals(nsISupports))
  223.         throw Components.results.NS_ERROR_NO_INTERFACE;
  224.  
  225.     return this;
  226. }
  227.  
  228. /* nsIChannel */
  229. BogusChannel.prototype.loadAttributes = null;
  230. BogusChannel.prototype.contentType = "x-application-irc";
  231. BogusChannel.prototype.contentLength = 0;
  232. BogusChannel.prototype.owner = null;
  233. BogusChannel.prototype.loadGroup = null;
  234. BogusChannel.prototype.notificationCallbacks = null;
  235. BogusChannel.prototype.securityInfo = null;
  236.  
  237. BogusChannel.prototype.open =
  238. BogusChannel.prototype.asyncOpen =
  239. function ()
  240. {
  241.     throw Components.results.NS_ERROR_NOT_IMPLEMENTED;
  242. }
  243.  
  244. BogusChannel.prototype.asyncOpen =
  245. function (observer, ctxt)
  246. {
  247.     observer.onStartRequest (this, ctxt);
  248. }
  249.  
  250. BogusChannel.prototype.asyncRead =
  251. function (listener, ctxt)
  252. {
  253.     return listener.onStartRequest (this, ctxt);
  254. }
  255.  
  256. /* nsIRequest */
  257. BogusChannel.prototype.isPending =
  258. function ()
  259. {
  260.     return true;
  261. }
  262.  
  263. BogusChannel.prototype.status = Components.results.NS_OK;
  264.  
  265. BogusChannel.prototype.cancel =
  266. function (aStatus)
  267. {
  268.     this.status = aStatus;
  269. }
  270.  
  271. BogusChannel.prototype.suspend =
  272. BogusChannel.prototype.resume =
  273. function ()
  274. {
  275.     throw Components.results.NS_ERROR_NOT_IMPLEMENTED;
  276. }
  277.  
  278. var ChatzillaModule = new Object();
  279.  
  280. ChatzillaModule.registerSelf =
  281. function (compMgr, fileSpec, location, type)
  282. {
  283.     dump("*** Registering -chat handler.\n");
  284.     compMgr.registerComponentWithType(CLINE_SERVICE_CID,
  285.                                       "Chatzilla CommandLine Service",
  286.                                       CLINE_SERVICE_CONTRACTID, fileSpec,
  287.                                       location, true, true, type);
  288.     
  289.     catman = Components.classes["@mozilla.org/categorymanager;1"]
  290.         .getService(nsICategoryManager);
  291.     catman.addCategoryEntry("command-line-argument-handlers",
  292.                             "chatzilla command line handler",
  293.                             CLINE_SERVICE_CONTRACTID, true, true);
  294.  
  295.     dump("*** Registering x-application-irc handler.\n");
  296.     compMgr.registerComponentWithType(IRCCNT_HANDLER_CID,
  297.                                       "IRC Content Handler",
  298.                                       IRCCNT_HANDLER_CONTRACTID, fileSpec,
  299.                                       location, true, true, type);
  300.  
  301.     dump("*** Registering irc protocol handler.\n");
  302.     compMgr.registerComponentWithType(IRCPROT_HANDLER_CID,
  303.                                       "IRC protocol handler",
  304.                                       IRCPROT_HANDLER_CONTRACTID, fileSpec, location,
  305.                                       true, true, type);
  306.  
  307. }
  308.  
  309. ChatzillaModule.unregisterSelf =
  310. function(compMgr, fileSpec, location)
  311. {
  312.     compMgr.unregisterComponentSpec(CLINE_SERVICE_CID, fileSpec);
  313.     catman = Components.classes["@mozilla.org/categorymanager;1"]
  314.         .getService(nsICategoryManager);
  315.     catman.deleteCategoryEntry("command-line-argument-handlers",
  316.                                CLINE_SERVICE_CONTRACTID, true);
  317. }
  318.  
  319. ChatzillaModule.getClassObject =
  320. function (compMgr, cid, iid) {
  321.     if (cid.equals(CLINE_SERVICE_CID))
  322.         return CLineFactory;
  323.  
  324.     if (cid.equals(IRCCNT_HANDLER_CID))
  325.         return IRCContentHandlerFactory;
  326.  
  327.     if (cid.equals(IRCPROT_HANDLER_CID))
  328.         return IRCProtocolHandlerFactory;
  329.     
  330.     if (!iid.equals(Components.interfaces.nsIFactory))
  331.         throw Components.results.NS_ERROR_NOT_IMPLEMENTED;
  332.  
  333.     throw Components.results.NS_ERROR_NO_INTERFACE;
  334.     
  335. }
  336.  
  337. ChatzillaModule.canUnload =
  338. function(compMgr)
  339. {
  340.     return true;
  341. }
  342.  
  343. /* entrypoint */
  344. function NSGetModule(compMgr, fileSpec) {
  345.     return ChatzillaModule;
  346. }
  347.