home *** CD-ROM | disk | FTP | other *** search
/ PC World 2003 May / PCWorld_2003-05_cd.bin / Komunik / phoenix / chrome / browser.jar / content / browser / pref / overrideHandler.js < prev    next >
Encoding:
JavaScript  |  2002-08-05  |  13.6 KB  |  429 lines
  1.  
  2. /** 
  3.  * Datasource initialization
  4.  **/
  5.  
  6. var gRDF = Components.classes["@mozilla.org/rdf/rdf-service;1"]
  7.                      .getService(Components.interfaces.nsIRDFService);
  8.  
  9. /**
  10.  * Handler Override class
  11.  **/
  12. function HandlerOverride(aURI)
  13. {
  14.   this.URI = aURI;
  15.   this.mUpdateMode = false;
  16. }
  17.  
  18. HandlerOverride.prototype = {
  19.   // general information
  20.   get mimeType()
  21.   {
  22.     return getLiteralForContentType(this.URI, "value");
  23.   },
  24.   
  25.   set mimeType(aMIMETypeString)
  26.   {
  27.     if (!this.mUpdateMode)
  28.       assertMIMEStuff(MIME_URI(aMIMETypeString), "value", aMIMETypeString.toLowerCase());
  29.     else
  30.       changeMIMEStuff(MIME_URI(aMIMETypeString), "value", aMIMETypeString.toLowerCase());
  31.   },
  32.   
  33.   get description()
  34.   {
  35.     return getLiteralForContentType(this.URI, "description");
  36.   },  
  37.   
  38.   set description(aDescriptionString)
  39.   {
  40.     if (!this.mUpdateMode)
  41.       assertMIMEStuff(MIME_URI(this.mimeType), "description", aDescriptionString);
  42.     else
  43.       changeMIMEStuff(MIME_URI(this.mimeType), "description", aDescriptionString);
  44.   },
  45.   
  46.   get isEditable()
  47.   {
  48.     return getLiteralForContentType(this.URI, "editable");
  49.   },
  50.   
  51.   set isEditable(aIsEditableString)
  52.   {
  53.     if (!this.mUpdateMode)
  54.       assertMIMEStuff(MIME_URI(this.mimeType), "editable", aIsEditableString);
  55.     else
  56.       changeMIMEStuff(MIME_URI(this.mimeType), "editable", aIsEditableString);
  57.   },
  58.   
  59.   get largeIconURL()
  60.   {
  61.     var url = getLiteralForContentType(this.URI, "largeIcon");
  62.     if (!url)
  63.       url = "chrome://communicator/skin/content-large.gif";
  64.     return url;
  65.   },
  66.   
  67.   set largeIconURL(aLargeIconURL)
  68.   {
  69.     if (!this.mUpdateMode)
  70.       assertMIMEStuff(MIME_URI(this.mimeType), "largeIcon", aLargeIconURL);
  71.     else
  72.       changeMIMEStuff(MIME_URI(this.mimeType), "largeIcon", aLargeIconURL);
  73.   },
  74.   
  75.   get smallIconURL()
  76.   {
  77.     var url = getLiteralForContentType(this.URI, "smallIcon");
  78.     if (!url)
  79.       url = "chrome://communicator/skin/content-small.gif";
  80.     return url;
  81.   },
  82.   
  83.   set smallIconURL(aSmallIconURL)
  84.   {
  85.     if (!this.mUpdateMode)
  86.       assertMIMEStuff(MIME_URI(this.mimeType), "smallIcon", aSmallIconURL);
  87.     else
  88.       changeMIMEStuff(MIME_URI(this.mimeType), "smallIcon", aSmallIconURL);
  89.   },
  90.  
  91.   get extensions()
  92.   {
  93.     var extensionResource = gRDF.GetResource(NC_RDF("fileExtensions"));
  94.     var contentTypeResource = gRDF.GetResource(MIME_URI(this.mimeType));
  95.     var extensionTargets  = gDS.GetTargets(contentTypeResource, extensionResource, true);
  96.     var extString = "";
  97.     if (extensionTargets) {
  98.       extensionTargets = extensionTargets.QueryInterface(Components.interfaces.nsISimpleEnumerator);
  99.       while (extensionTargets.hasMoreElements()) {
  100.         var currentExtension = extensionTargets.getNext();
  101.         if (currentExtension) {
  102.           currentExtension = currentExtension.QueryInterface(Components.interfaces.nsIRDFLiteral);
  103.           extString += currentExtension.Value.toLowerCase() + " ";
  104.         }
  105.       }
  106.     }
  107.     return extString;
  108.   },
  109.   
  110.   addExtension: function (aExtensionString)
  111.   {
  112.     assertMIMEStuff(MIME_URI(this.mimeType), "fileExtensions", aExtensionString.toLowerCase());
  113.   },
  114.   
  115.   removeExtension: function (aExtensionString)
  116.   {
  117.     unassertMIMEStuff(MIME_URI(this.mimeType), "fileExtensions", aExtensionString.toLowerCase());
  118.   },
  119.   
  120.   // content handling
  121.   get saveToDisk()
  122.   {
  123.     return getHandlerInfoForType(this.URI, "saveToDisk");
  124.   },
  125.   
  126.   set saveToDisk(aSavedToDisk)
  127.   {
  128.     var handlerSource = gRDF.GetResource(HANDLER_URI(this.mimeType));
  129.     var handlerProperty = gRDF.GetResource(NC_RDF("saveToDisk"));
  130.     var trueLiteral = gRDF.GetLiteral("true");
  131.     var hasSaveToDisk = gDS.HasAssertion(handlerSource, handlerProperty, trueLiteral, true);
  132.     if (!hasSaveToDisk) {
  133.       var falseLiteral = gRDF.GetLiteral("false");
  134.       hasSaveToDisk = gDS.HasAssertion(handlerSource, handlerProperty, falseLiteral, true);
  135.     }
  136.     if (!this.mUpdateMode || !hasSaveToDisk)
  137.       assertMIMEStuff(HANDLER_URI(this.mimeType), "saveToDisk", aSavedToDisk);
  138.     else
  139.       changeMIMEStuff(HANDLER_URI(this.mimeType), "saveToDisk", aSavedToDisk);
  140.     this.setHandlerProcedure("handleInternal", "false");
  141.  },
  142.   
  143.   get handleInternal()
  144.   {
  145.     return getHandlerInfoForType(this.URI, "handleInternal");
  146.   },
  147.   
  148.   set handleInternal(aHandledInternally)
  149.   {
  150.     var handlerSource = gRDF.GetResource(HANDLER_URI(this.mimeType));
  151.     var handlerProperty = gRDF.GetResource(NC_RDF("handleInternal"));
  152.     var trueLiteral = gRDF.GetLiteral("true");
  153.     var hasHandleInternal = gDS.HasAssertion(handlerSource, handlerProperty, trueLiteral, true);
  154.     if (!hasHandleInternal) {
  155.       var falseLiteral = gRDF.GetLiteral("false");
  156.       hasHandleInternal = gDS.HasAssertion(handlerSource, handlerProperty, falseLiteral, true);
  157.     }
  158.     if (!this.mUpdateMode || !hasHandleInternal)
  159.       assertMIMEStuff(HANDLER_URI(this.mimeType), "handleInternal", aHandledInternally);
  160.     else
  161.       changeMIMEStuff(HANDLER_URI(this.mimeType), "handleInternal", aHandledInternally);
  162.     this.setHandlerProcedure("saveToDisk", "false");
  163.   },
  164.  
  165.   setHandlerProcedure: function (aHandlerProcedure, aValue)
  166.   {
  167.     var handlerSource = gRDF.GetResource(HANDLER_URI(this.mimeType));
  168.     var handlerProperty = gRDF.GetResource(NC_RDF(aHandlerProcedure));
  169.     var oppositeValue = aValue == "false" ? "true" : "false";
  170.     var trueLiteral = gRDF.GetLiteral(oppositeValue);
  171.     var hasCounterpart = gDS.HasAssertion(handlerSource, handlerProperty, trueLiteral, true);
  172.     if (hasCounterpart) {
  173.       var falseLiteral = gRDF.GetLiteral(aValue);
  174.       gDS.Change(handlerSource, handlerProperty, trueLiteral, falseLiteral);
  175.     }
  176.   },
  177.   
  178.   get alwaysAsk()
  179.   {
  180.     return getHandlerInfoForType(this.URI, "alwaysAsk");
  181.   },
  182.   
  183.   set alwaysAsk(aAlwaysAsk)
  184.   {
  185.     if (!this.mUpdateMode)
  186.       assertMIMEStuff(HANDLER_URI(this.mimeType), "alwaysAsk", aAlwaysAsk);
  187.     else
  188.       changeMIMEStuff(HANDLER_URI(this.mimeType), "alwaysAsk", aAlwaysAsk);
  189.   },
  190.   
  191.   // helper application
  192.   get appDisplayName()
  193.   {
  194.     return getHelperAppInfoForType(this.URI, "prettyName");
  195.   },
  196.   
  197.   set appDisplayName(aDisplayName)
  198.   {
  199.     if (!this.mUpdateMode)
  200.       assertMIMEStuff(APP_URI(this.mimeType), "prettyName", aDisplayName);
  201.     else
  202.       changeMIMEStuff(APP_URI(this.mimeType), "prettyName", aDisplayName);
  203.   },
  204.   
  205.   get appPath()
  206.   {
  207.     return getHelperAppInfoForType(this.URI, "path");
  208.   },
  209.   
  210.   set appPath(aAppPath)
  211.   {
  212.     if (!this.mUpdateMode)
  213.       assertMIMEStuff(APP_URI(this.mimeType), "path", aAppPath);
  214.     else
  215.       changeMIMEStuff(APP_URI(this.mimeType), "path", aAppPath);
  216.   },
  217.  
  218.   /**
  219.    * After setting the various properties on this override, we need to
  220.    * build the links between the mime type resource, the handler for that
  221.    * resource, and the helper app (if any) associated with the resource.
  222.    * We also need to add this mime type to the RDF seq (list) of types.
  223.    **/
  224.   buildLinks: function()
  225.   {
  226.     // assert the handler resource
  227.     var mimeSource = gRDF.GetResource(MIME_URI(this.mimeType));
  228.     var handlerProperty = gRDF.GetResource(NC_RDF("handlerProp"));
  229.     var handlerResource = gRDF.GetResource(HANDLER_URI(this.mimeType));
  230.     gDS.Assert(mimeSource, handlerProperty, handlerResource, true);
  231.     // assert the helper app resource
  232.     var helperAppProperty = gRDF.GetResource(NC_RDF("externalApplication"));
  233.     var helperAppResource = gRDF.GetResource(APP_URI(this.mimeType));
  234.     gDS.Assert(handlerResource, helperAppProperty, helperAppResource, true);
  235.     // add the mime type to the MIME types seq
  236.     var container = Components.classes["@mozilla.org/rdf/container;1"].createInstance();
  237.     if (container) {
  238.       container = container.QueryInterface(Components.interfaces.nsIRDFContainer);
  239.       if (container) {
  240.         var containerRes = gRDF.GetResource("urn:mimetypes:root");
  241.         container.Init(gDS, containerRes);
  242.         var element = gRDF.GetResource(MIME_URI(this.mimeType));
  243.         if (container.IndexOf(element) == -1)
  244.           container.AppendElement(element);
  245.       }
  246.     }
  247.   }
  248.  
  249. };
  250.  
  251. /** 
  252.  * Utility functions for building URIs easily
  253.  **/
  254. function NC_RDF(aProperty)
  255. {
  256.   return "http://home.netscape.com/NC-rdf#" + aProperty;
  257. }
  258.  
  259. function HANDLER_URI(aHandler)
  260. {
  261.   return "urn:mimetype:handler:" + aHandler;
  262. }
  263.  
  264. function APP_URI(aType)
  265. {
  266.   return "urn:mimetype:externalApplication:" + aType;
  267. }
  268.  
  269. function MIME_URI(aType)
  270. {
  271.   return "urn:mimetype:" + aType;
  272. }
  273.  
  274. /**
  275.  * Utility functions for reading data from the RDF datasource
  276.   **/
  277. function getLiteralForContentType(aURI, aProperty)
  278. {
  279.   var contentTypeResource = gRDF.GetResource(aURI);
  280.   var propertyResource = gRDF.GetResource(NC_RDF(aProperty));
  281.   return getLiteral(contentTypeResource, propertyResource);
  282. }
  283.  
  284. function getLiteral(aSource, aProperty)
  285. {
  286.   var node = gDS.GetTarget(aSource, aProperty, true);
  287.   if (node) {
  288.     node = node.QueryInterface(Components.interfaces.nsIRDFLiteral);
  289.     return node.Value;
  290.   }
  291.   return "";
  292. }
  293.  
  294. function getHandlerInfoForType(aURI, aPropertyString)
  295. {
  296.   // get current selected type
  297.   var handler = HANDLER_URI(getLiteralForContentType(aURI, "value"));
  298.   var source = gRDF.GetResource(handler);
  299.   var property = gRDF.GetResource(NC_RDF(aPropertyString));
  300.   var target = gDS.GetTarget(source, property, true);
  301.   if (target) {
  302.     target = target.QueryInterface(Components.interfaces.nsIRDFLiteral);
  303.     return target.Value;
  304.   }
  305.   return "";
  306. }
  307.  
  308. function getHelperAppInfoForType(aURI, aPropertyString)
  309. {
  310.   var appURI      = APP_URI(getLiteralForContentType(aURI, "value"));
  311.   var appRes      = gRDF.GetResource(appURI);
  312.   var appProperty = gRDF.GetResource(NC_RDF(aPropertyString));
  313.   return getLiteral(appRes, appProperty);
  314. }
  315.  
  316. function mimeHandlerExists(aMIMEType)
  317. {
  318.   var valueProperty = gRDF.GetResource(NC_RDF("value"));
  319.   var mimeSource = gRDF.GetResource(MIME_URI(aMIMEType));
  320.   var mimeLiteral = gRDF.GetLiteral(gMIMEField.value);
  321.   return gDS.HasAssertion(mimeSource, valueProperty, mimeLiteral, true);
  322. }
  323.  
  324. // write to the ds
  325. function assertMIMEStuff(aMIMEString, aPropertyString, aValueString)
  326. {
  327.   var mimeSource = gRDF.GetResource(aMIMEString);
  328.   var valueProperty = gRDF.GetResource(NC_RDF(aPropertyString));
  329.   var mimeLiteral = gRDF.GetLiteral(aValueString);
  330.   gDS.Assert(mimeSource, valueProperty, mimeLiteral, true);
  331. }
  332.  
  333. function changeMIMEStuff(aMIMEString, aPropertyString, aValueString)
  334. {
  335.   var mimeSource = gRDF.GetResource(aMIMEString);
  336.   var valueProperty = gRDF.GetResource(NC_RDF(aPropertyString));
  337.   var mimeLiteral = gRDF.GetLiteral(aValueString);
  338.   var currentValue = gDS.GetTarget(mimeSource, valueProperty, true);
  339.   gDS.Change(mimeSource, valueProperty, currentValue, mimeLiteral);
  340. }
  341.  
  342. function unassertMIMEStuff(aMIMEString, aPropertyString, aValueString)
  343. {
  344.   var mimeSource = gRDF.GetResource(aMIMEString);
  345.   var valueProperty = gRDF.GetResource(NC_RDF(aPropertyString));
  346.   var mimeLiteral = gRDF.GetLiteral(aValueString);
  347.   gDS.Unassert(mimeSource, valueProperty, mimeLiteral, true);
  348. }
  349.  
  350. function removeOverride(aMIMEType)
  351. {
  352.   dump("*** mimeType = " + aMIMEType + "\n");
  353.   // remove entry from seq
  354.   var rdfc = Components.classes["@mozilla.org/rdf/container;1"].createInstance();
  355.   if (rdfc) {
  356.     rdfc = rdfc.QueryInterface(Components.interfaces.nsIRDFContainer);
  357.     if (rdfc) {
  358.       var containerRes = gRDF.GetResource("urn:mimetypes:root");
  359.       rdfc.Init(gDS, containerRes);
  360.       var element = gRDF.GetResource(MIME_URI(aMIMEType));
  361.       if (rdfc.IndexOf(element) != -1) {
  362.         try {
  363.           rdfc.RemoveElement(element, true);
  364.         }
  365.         catch(e) {
  366.           // suppress (benign?) errors
  367.         } 
  368.       }
  369.     }
  370.   }
  371.   
  372.   // remove items from the graph  
  373.   var urns = [ [MIME_URI, ["description", "editable", "value", "fileExtensions", "smallIcon", "largeIcon"], 
  374.                           [HANDLER_URI, "handlerProp"]],               
  375.                [HANDLER_URI, ["handleInternal", "saveToDisk", "alwaysAsk"], 
  376.                           [APP_URI, "externalApplication"]],              
  377.                [APP_URI, ["path", "prettyName"]] ];
  378.   for (var i = 0; i < urns.length; i++) {
  379.     var mimeRes = gRDF.GetResource(urns[i][0](aMIMEType));
  380.     // unassert the toplevel properties
  381.     var properties = urns[i][1];
  382.     for (var j = 0; j < properties.length; j++) {
  383.       var propertyRes = gRDF.GetResource(NC_RDF(properties[j]), true);
  384.       if (properties[j] == "fileExtensions") {  // hacky. do it better next time. 
  385.         var mimeValues = gDS.GetTargets(mimeRes, propertyRes, true);
  386.         mimeValues = mimeValues.QueryInterface(Components.interfaces.nsISimpleEnumerator);
  387.         while (mimeValues.hasMoreElements()) {
  388.           var currItem = mimeValues.getNext();
  389.           if (mimeRes && propertyRes && currItem) 
  390.             gDS.Unassert(mimeRes, propertyRes, currItem, true);
  391.         }
  392.       }
  393.       else {
  394.         var mimeValue = gDS.GetTarget(mimeRes, propertyRes, true);
  395.         if (mimeRes && propertyRes && mimeValue)
  396.           gDS.Unassert(mimeRes, propertyRes, mimeValue, true);
  397.       }
  398.     }
  399.     if (urns[i][2]) {
  400.       var linkRes = gRDF.GetResource(NC_RDF(urns[i][2][1]), true);
  401.       var linkTarget = gRDF.GetResource(urns[i][2][0](aMIMEType), true);
  402.       gDS.Unassert(mimeRes, linkRes, linkTarget);
  403.     }
  404.   }
  405.   try {
  406.     gDS.QueryInterface(Components.interfaces.nsIRDFRemoteDataSource).Flush();
  407.   } catch(e) {
  408.   }
  409. }
  410.  
  411. function checkInput() {
  412.   var result = true;
  413.   // Check for empty MIME type field.
  414.   if ( gMIMEField.value.search(/\S/) == -1 ) {
  415.     // Input is not OK.
  416.     result = false;
  417.  
  418.     // Focus the mime type field.
  419.     gMIMEField.focus();
  420.  
  421.     // Put up alert.  Title is same as parent dialog's.
  422.     var title    = window.document.documentElement.getAttribute( "title" );
  423.     var text     = gPrefApplicationsBundle.getString("emptyMIMEType");
  424.     var prompter = Components.classes["@mozilla.org/embedcomp/prompt-service;1"].getService(Components.interfaces.nsIPromptService);
  425.     prompter.alert(window, title, text);
  426.   }
  427.   return result;
  428. }
  429.