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