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