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 / helperApps.js < prev    next >
Text File  |  2005-07-29  |  22KB  |  665 lines
  1.  
  2. var gRDF;    
  3.  
  4. ///////////////////////////////////////////////////////////////////////////////
  5. // MIME Types DataSource Wrapper
  6.  
  7. function NC_URI(aProperty)
  8. {
  9.   return "http://home.netscape.com/NC-rdf#" + aProperty;
  10. }
  11.  
  12. function MIME_URI(aType)
  13. {
  14.   return "urn:mimetype:" + aType;
  15. }
  16.  
  17. function HANDLER_URI(aHandler)
  18. {
  19.   return "urn:mimetype:handler:" + aHandler;
  20. }
  21.  
  22. function APP_URI(aType)
  23. {
  24.   return "urn:mimetype:externalApplication:" + aType;
  25. }
  26.  
  27. function ArrayEnumerator(aItems)
  28. {
  29.   this._index = 0;
  30.   
  31.   if (aItems) {
  32.     for (var i = 0; i < aItems.length; ++i) {    
  33.       if (!aItems[i])
  34.         aItems.splice(i, 1);      
  35.     }
  36.   }
  37.   
  38.   this._contents = aItems || [];
  39.  
  40.   this.push = function (aElement) 
  41.   {
  42.     if (aElement)
  43.       this._contents.push(aElement);
  44.   };
  45.   
  46.   this.hasMoreElements = function ()
  47.   {
  48.     return this._index < this._contents.length;
  49.   };
  50.   
  51.   this.getNext = function ()
  52.   {
  53.     return this._contents[this._index++];      
  54.   };
  55. };
  56.  
  57. function HelperApps()
  58. {
  59.   if (!gRDF) 
  60.     gRDF = Components.classes["@mozilla.org/rdf/rdf-service;1"].getService(Components.interfaces.nsIRDFService);
  61.   
  62.   const mimeTypes = "UMimTyp";
  63.   var fileLocator = Components.classes["@mozilla.org/file/directory_service;1"].getService(Components.interfaces.nsIProperties);
  64.   
  65.   var file = fileLocator.get(mimeTypes, Components.interfaces.nsIFile);
  66.  
  67.   var ioService = Components.classes["@mozilla.org/network/io-service;1"].getService(Components.interfaces.nsIIOService);
  68.   var fileHandler = ioService.getProtocolHandler("file").QueryInterface(Components.interfaces.nsIFileProtocolHandler);
  69.   this._inner = gRDF.GetDataSourceBlocking(fileHandler.getURLSpecFromFile(file));
  70.   this._inner.AddObserver(this);
  71.  
  72.   this._fileTypeArc       = gRDF.GetResource(NC_URI("FileType"));
  73.   this._fileHandlerArc    = gRDF.GetResource(NC_URI("FileHandler"));
  74.   this._fileIconArc       = gRDF.GetResource(NC_URI("FileIcon"));
  75.   this._fileExtensionArc  = gRDF.GetResource(NC_URI("FileExtension"));
  76.   this._fileExtensionsArc = gRDF.GetResource(NC_URI("FileExtensions"));
  77.   this._handleAutoArc     = gRDF.GetResource(NC_URI("FileHandleAuto"));
  78.   this._valueArc          = gRDF.GetResource(NC_URI("value"));
  79.   this._handlerPropArc    = gRDF.GetResource(NC_URI("handlerProp"));
  80.   this._externalAppArc    = gRDF.GetResource(NC_URI("externalApplication"));
  81. }
  82.  
  83. HelperApps.prototype = {
  84.   mimeHandlerExists: function (aMIMEType)
  85.   {
  86.     var valueProperty = gRDF.GetUnicodeResource(NC_URI("value"));
  87.     var mimeSource = gRDF.GetUnicodeResource(MIME_URI(aMIMEType));
  88.     var mimeLiteral = gRDF.GetLiteral(aMIMEType);
  89.     return this._inner.HasAssertion(mimeSource, valueProperty, mimeLiteral, true);
  90.   },
  91.  
  92.   updateTypeInfo: function (aMIMEInfo) 
  93.   {
  94.     var mimeType = aMIMEInfo.MIMEType;
  95.     var isNewMIMEType = this.mimeHandlerExists(mimeType);
  96.     var entry = new HandlerOverride(MIME_URI(mimeType), this._inner);
  97.     entry.mimeType    = mimeType;
  98.     entry.isEditable  = true;
  99.     entry.alwaysAsk = aMIMEInfo.alwaysAskBeforeHandling;
  100.     
  101.     // If not updating (i.e., a newly encountered mime type),
  102.     // then update extension list and description.
  103.     if (!isNewMIMEType) {
  104.       var extEnumerator = aMIMEInfo.getFileExtensions();
  105.       while (extEnumerator.hasMore()) {
  106.           entry.addExtension(extEnumerator.getNext());
  107.       }
  108.       entry.description = aMIMEInfo.Description;
  109.       entry.appDisplayName = "";
  110.     }
  111.     
  112.     const nsIMIMEInfo = Components.interfaces.nsIMIMEInfo;
  113.     if (aMIMEInfo.preferredAction == nsIMIMEInfo.saveToDisk) {
  114.       entry.saveToDisk = true;
  115.       if (!isNewMIMEType) {
  116.         // Creating a new entry, set path.
  117.         entry.appPath = "";
  118.       }
  119.     } 
  120.     else if (aMIMEInfo.preferredAction == nsIMIMEInfo.useSystemDefault ||
  121.              aMIMEInfo.preferredApplicationHandler == null) {
  122.       entry.useSystemDefault = true;
  123.       if (!isNewMIMEType) {
  124.         // Creating a new entry, set path.
  125.         entry.appPath = "";
  126.       }
  127.     } 
  128.     else {
  129.       entry.saveToDisk       = false;
  130.       entry.useSystemDefault = false;
  131.       entry.handleInternal   = false;
  132.       entry.appPath = aMIMEInfo.preferredApplicationHandler.path;
  133.       entry.appDisplayName = aMIMEInfo.applicationDescription;
  134.     }
  135.     
  136.     // Do RDF magic.
  137.     entry.buildLinks();
  138.     this.flush();
  139.   },
  140.  
  141.   getLiteralValue: function (aResource, aProperty)
  142.   {
  143.     var res = gRDF.GetResource(aResource);
  144.     var prop = gRDF.GetResource(NC_URI(aProperty));
  145.     var val = this.GetTarget(res, prop, true);
  146.     if (val) {
  147.       val = val.QueryInterface(Components.interfaces.nsIRDFLiteral);
  148.       return val.Value;
  149.     }
  150.     return "";
  151.   },
  152.  
  153.   /* nsIRDFDataSource */
  154.   get URI() {
  155.     return this._inner.URI;
  156.   },
  157.   
  158.   GetSource: function (aProperty, aTarget, aTruthValue) {
  159.     return this._inner.GetSource(aProperty, aTarget, aTruthValue);
  160.   },
  161.   GetSources: function (aProperty, aTarget, aTruthValue) {
  162.     return this._inner.GetSources(aProperty, aTarget, aTruthValue);
  163.   },         
  164.   
  165.   _isRootTypeResource: function (aResource) {
  166.     aResource = aResource.QueryInterface(Components.interfaces.nsIRDFResource);  
  167.     const kRootTypePrefix = "urn:mimetype:";
  168.     return (aResource.Value.substr(0, kRootTypePrefix.length) == kRootTypePrefix);
  169.   },
  170.   
  171.   getMIMEInfo: function (aResource) {
  172.     var types = this._inner.GetTarget(aResource, this._valueArc, true);
  173.     if (types) {
  174.       types = types.QueryInterface(Components.interfaces.nsIRDFLiteral);
  175.       types = types.Value.split(", ");
  176.       
  177.       // We're using helper app service as our MIME Service here because the helper app service
  178.       // talks to OS Specific hooks that on some platforms (MacOS X) are required to get a 
  179.       // fully populated MIME Info object. Thus it is this object that we return. 
  180.       mimeSvc = Components.classes["@mozilla.org/uriloader/external-helper-app-service;1"].getService(Components.interfaces.nsIMIMEService);
  181.       return mimeSvc.getFromTypeAndExtension(types[0], null);
  182.     }
  183.     
  184.     return null;
  185.   },
  186.    
  187.   GetTarget: function (aSource, aProperty, aTruthValue) {
  188.     if (this._isRootTypeResource(aSource)) {
  189.       var typeInfo = this.getMIMEInfo(aSource);
  190.       if (typeInfo) {
  191.         var bundle = document.getElementById("strings");
  192.         if (aProperty.EqualsNode(this._handleAutoArc)) {
  193.           var handler = this.GetTarget(aSource, this._handlerPropArc, true);
  194.           if (handler) {
  195.             handler = handler.QueryInterface(Components.interfaces.nsIRDFResource);
  196.             return gRDF.GetLiteral(!(this.getLiteralValue(handler.Value, "alwaysAsk") == "true"));
  197.           }
  198.         }
  199.         else if (aProperty.EqualsNode(this._fileTypeArc)) {
  200.           if (typeInfo.Description == "") {
  201.             try {
  202.               var literal = bundle.getFormattedString("fileEnding", [typeInfo.primaryExtension.toUpperCase()]);
  203.               return gRDF.GetLiteral(literal);
  204.             }
  205.             catch (e) { 
  206.               // Wow, this sucks, just show the MIME type as a last ditch effort to display
  207.               // the type of file that this is. 
  208.               return gRDF.GetLiteral(typeInfo.MIMEType);
  209.             }
  210.           }
  211.           return gRDF.GetLiteral(typeInfo.Description);
  212.         }
  213.         else if (aProperty.EqualsNode(this._fileHandlerArc)) {
  214.           var handler = this.GetTarget(aSource, this._handlerPropArc, true);
  215.           if (handler) {
  216.             handler = handler.QueryInterface(Components.interfaces.nsIRDFResource);
  217.             if (this.getLiteralValue(handler.Value, "saveToDisk") == "true") {
  218.               var saveToDisk = bundle.getString("saveToDisk");
  219.               return gRDF.GetLiteral(saveToDisk);
  220.             }
  221.             else if (this.getLiteralValue(handler.Value, "useSystemDefault") == "false") {
  222.               var extApp = this.GetTarget(handler, this._externalAppArc, true);
  223.               if (extApp) {
  224.                 extApp = extApp.QueryInterface(Components.interfaces.nsIRDFResource);
  225.                 var openWith = bundle.getFormattedString("openWith", [this.getLiteralValue(extApp.Value, "prettyName")]);
  226.                 return gRDF.GetLiteral(openWith);
  227.               }
  228.             }
  229.           }     
  230.           
  231.           var openWith2 = bundle.getFormattedString("openWith", [typeInfo.defaultDescription]);
  232.           return gRDF.GetLiteral(openWith2);
  233.         }
  234.         else if (aProperty.EqualsNode(this._fileIconArc)) {
  235.           try {
  236.             return gRDF.GetLiteral("moz-icon://goat." + typeInfo.primaryExtension + "?size=16");
  237.           }
  238.           catch (e) {
  239.             return gRDF.GetLiteral("moz-icon://goat?size=16&contentType=" + typeInfo.MIMEType);
  240.           }
  241.         }
  242.         else if (aProperty.EqualsNode(this._fileExtensionArc)) {
  243.           try {
  244.             return gRDF.GetLiteral(typeInfo.primaryExtension.toUpperCase());
  245.           }
  246.           catch (e) { }
  247.           return gRDF.GetLiteral("");
  248.         }
  249.         else if (aProperty.EqualsNode(this._fileExtensionsArc)) {
  250.           var extns = typeInfo.getFileExtensions();
  251.           
  252.           // Prevent duplicates.
  253.           var hash = { };
  254.           while (extns.hasMore())
  255.             hash[extns.getNext().toUpperCase()] = 0;
  256.           
  257.           var str = "";
  258.           for (var extn in hash)
  259.             str += extn + ",";
  260.           str = str.substring(0, str.length - 1);
  261.  
  262.           return gRDF.GetLiteral(str);
  263.         }
  264.       }
  265.     }
  266.  
  267.     return this._inner.GetTarget(aSource, aProperty, aTruthValue);
  268.   },      
  269.   
  270.   GetTargets: function (aSource, aProperty, aTruthValue) {
  271.     if (this._isRootTypeResource(aSource)) { 
  272.       return new ArrayEnumerator([this.GetTarget(aSource, aProperty, aTruthValue)]);
  273.     }
  274.     
  275.     return this._inner.GetTargets(aSource, aProperty, aTruthValue);
  276.   }, 
  277.   Assert: function (aSource, aProperty, aTarget, aTruthValue) {
  278.     return this._inner.Assert(aSource, aProperty, aTarget, aTruthValue);
  279.   },
  280.   Unassert: function (aSource, aProperty, aTarget) {
  281.     return this._inner.Unassert(aSource, aProperty, aTarget);
  282.   },
  283.   Change: function (aSource, aProperty, aOldTarget, aNewTarget) {
  284.     if (aOldTarget)
  285.       var ot = aOldTarget.QueryInterface(Components.interfaces.nsIRDFLiteral);
  286.     if (aNewTarget)
  287.       var nt = aNewTarget.QueryInterface(Components.interfaces.nsIRDFLiteral);
  288.  
  289.     return this._inner.Change(aSource, aProperty, aOldTarget, aNewTarget);
  290.   },
  291.   Move: function (aOldSource, aNewSource, aProperty, aTarget) {
  292.     return this._inner.Assert(aOldSource, aNewSource, aProperty, aTarget);
  293.   },
  294.   HasAssertion: function (aSource, aProperty, aTarget, aTruthValue) {
  295.     if (this._isRootTypeResource(aSource)) {
  296.       // Don't show entries in the list for types that we DO NOT handle
  297.       // automatically. i.e. this list is a means of editing and removing
  298.       // automatic overrides only. 
  299.       if (aProperty.EqualsNode(this._handleAutoArc)) {
  300.         var handler = this.GetTarget(aSource, this._handlerPropArc, true);
  301.         if (handler) {
  302.           handler = handler.QueryInterface(Components.interfaces.nsIRDFResource);
  303.           return !(this.getLiteralValue(handler.Value, "alwaysAsk") == "true");
  304.         }
  305.       }
  306.     }
  307.     return this._inner.HasAssertion(aSource, aProperty, aTarget, aTruthValue);
  308.   },
  309.   AddObserver: function (aObserver) {
  310.     this._inner.AddObserver(aObserver);
  311.   },
  312.   RemoveObserver: function (aObserver) {
  313.     this._inner.RemoveObserver(aObserver);
  314.   },
  315.   ArcLabelsIn: function (aNode) {
  316.     return this._inner.ArcLabelsIn(aNode);
  317.   },
  318.   ArcLabelsOut: function (aNode) {
  319.     return this._inner.ArcLabelsOut(aNode);
  320.   },
  321.   GetAllResources: function () {
  322.     return this._inner.GetAllResources();
  323.   },
  324.   hasArcIn: function (aNode, aArc) {
  325.     return this._inner.hasArcIn(aNode, aArc);
  326.   },
  327.   hasArcOut: function (aNode, aArc) {
  328.     return this._inner.hasArcOut(aNode, aArc);
  329.   },
  330.   
  331.   _observers: [],
  332.   AddObserver: function (aObserver) {
  333.     this._observers.push(aObserver);
  334.   },
  335.   
  336.   RemoveObserver: function (aObserver) {
  337.     for (var i = 0; i < this._observers.length; ++i) {
  338.       if (this._observers[i] == aObserver) {
  339.         this._observers.splice(i, 1);
  340.         break;
  341.       }
  342.     }
  343.   },
  344.   
  345.   onAssert: function (aDataSource, aSource, aProperty, aTarget) {
  346.     for (var i = 0; i < this._observers.length; ++i) {
  347.       this._observers[i].onAssert(aDataSource, aSource, aProperty, aTarget);
  348.     }
  349.   },
  350.  
  351.   onUnassert: function (aDataSource, aSource, aProperty, aTarget) {
  352.     for (var i = 0; i < this._observers.length; ++i) {
  353.       this._observers[i].onUnassert(aDataSource, aSource, aProperty, aTarget);
  354.     }
  355.   },
  356.   
  357.   onChange: function (aDataSource, aSource, aProperty, aOldTarget, aNewTarget) {
  358.     for (var i = 0; i < this._observers.length; ++i) {
  359.       this._observers[i].onChange(aDataSource, aSource, aProperty, aOldTarget, aNewTarget);
  360.     }
  361.   },
  362.   
  363.   onMove: function (aDataSource, aOldSource, aNewSource, aProperty, aTarget) {
  364.     for (var i = 0; i < this._observers.length; ++i) {
  365.       this._observers[i].onMove(aDataSource, aOldSource, aNewSource, aProperty, aTarget);
  366.     }
  367.   },
  368.   
  369.   beginUpdateBatch: function (aDataSource) {
  370.     for (var i = 0; i < this._observers.length; ++i) {
  371.       this._observers[i].beginUpdateBatch(aDataSource);
  372.     }
  373.   },
  374.   
  375.   endUpdateBatch: function (aDataSource) {
  376.     for (var i = 0; i < this._observers.length; ++i) {
  377.       this._observers[i].endUpdateBatch(aDataSource);
  378.     }
  379.   },
  380.  
  381.   flush: function () {
  382.     var rds = this._inner.QueryInterface(Components.interfaces.nsIRDFRemoteDataSource);
  383.     if (rds) 
  384.       rds.Flush();
  385.   },
  386.   
  387.   destroy: function () {
  388.     this._inner.RemoveObserver(this);
  389.   }
  390. };
  391.  
  392. /**
  393.  * Handler Override class
  394.  **/
  395. function HandlerOverride(aURI, aDatasource)
  396. {
  397.   this.URI = aURI;
  398.   this._DS = aDatasource;
  399. }
  400.  
  401. HandlerOverride.prototype = {
  402.   // general information
  403.   get mimeType()
  404.   {
  405.     return this.getLiteralForContentType(this.URI, "value");
  406.   },
  407.   
  408.   set mimeType(aMIMETypeString)
  409.   {
  410.     this.changeMIMEStuff(MIME_URI(aMIMETypeString), "value", aMIMETypeString.toLowerCase());
  411.     return aMIMETypeString;
  412.   },
  413.   
  414.   get description()
  415.   {
  416.     return this.getLiteralForContentType(this.URI, "description");
  417.   },  
  418.   
  419.   set description(aDescriptionString)
  420.   {
  421.     this.changeMIMEStuff(MIME_URI(this.mimeType), "description", aDescriptionString);
  422.     return aDescriptionString;
  423.   },
  424.   
  425.   get isEditable()
  426.   {
  427.     return this.getLiteralForContentType(this.URI, "editable");
  428.   },
  429.   
  430.   set isEditable(aIsEditableString)
  431.   {
  432.     this.changeMIMEStuff(MIME_URI(this.mimeType), "editable", aIsEditableString);
  433.     return aIsEditableString;
  434.   },
  435.  
  436.   get extensions()
  437.   {
  438.     var extensionResource = gRDF.GetUnicodeResource(NC_URI("fileExtensions"));
  439.     var contentTypeResource = gRDF.GetUnicodeResource(MIME_URI(this.mimeType));
  440.     var extensionTargets = this._DS.GetTargets(contentTypeResource, extensionResource, true);
  441.     var extString = "";
  442.     if (extensionTargets) {
  443.       while (extensionTargets.hasMoreElements()) {
  444.         var currentExtension = extensionTargets.getNext();
  445.         if (currentExtension) {
  446.           currentExtension = currentExtension.QueryInterface(Components.interfaces.nsIRDFLiteral);
  447.           if (extString != "") {
  448.             extString += " ";
  449.           }
  450.           extString += currentExtension.Value.toLowerCase();
  451.         }
  452.       }
  453.     }
  454.     return extString;
  455.   },
  456.   
  457.   addExtension: function (aExtensionString)
  458.   {
  459.     this.assertMIMEStuff(MIME_URI(this.mimeType), "fileExtensions", aExtensionString.toLowerCase());
  460.   },
  461.   
  462.   removeExtension: function (aExtensionString)
  463.   {
  464.     this.unassertMIMEStuff(MIME_URI(this.mimeType), "fileExtensions", aExtensionString.toLowerCase());
  465.   },
  466.  
  467.   clearExtensions: function ()
  468.   {
  469.     var extArray = this.extensions.split(" ");
  470.     for (i = extArray.length - 1; i >= 0; --i) {
  471.       this.removeExtension(extArray[i]);
  472.     }
  473.   },
  474.   
  475.   // content handling
  476.   get saveToDisk()
  477.   {
  478.     return this.getHandlerInfoForType(this.URI, "saveToDisk");
  479.   },
  480.   
  481.   set saveToDisk(aSavedToDisk)
  482.   {
  483.     this.changeMIMEStuff(HANDLER_URI(this.mimeType), "saveToDisk", aSavedToDisk);
  484.     this.setHandlerProcedure("handleInternal", "false");
  485.     this.setHandlerProcedure("useSystemDefault", "false");
  486.     return aSavedToDisk;
  487.  },
  488.  
  489.   get useSystemDefault()
  490.   {
  491.     return this.getHandlerInfoForType(this.URI, "useSystemDefault");
  492.   },
  493.  
  494.   set useSystemDefault(aUseSystemDefault)
  495.   {
  496.     this.changeMIMEStuff(HANDLER_URI(this.mimeType), "useSystemDefault", aUseSystemDefault);
  497.     this.setHandlerProcedure("handleInternal", "false");
  498.     this.setHandlerProcedure("saveToDisk", "false");
  499.     return aUseSystemDefault;
  500.   },
  501.   
  502.   get handleInternal()
  503.   {
  504.     return this.getHandlerInfoForType(this.URI, "handleInternal");
  505.   },
  506.   
  507.   set handleInternal(aHandledInternally)
  508.   {
  509.     this.changeMIMEStuff(HANDLER_URI(this.mimeType), "handleInternal", aHandledInternally);
  510.     this.setHandlerProcedure("saveToDisk", "false");
  511.     this.setHandlerProcedure("useSystemDefault", "false");
  512.     return aHandledInternally;
  513.   },
  514.  
  515.   setHandlerProcedure: function (aHandlerProcedure, aValue)
  516.   {
  517.     var handlerSource = gRDF.GetUnicodeResource(HANDLER_URI(this.mimeType));
  518.     var handlerProperty = gRDF.GetUnicodeResource(NC_URI(aHandlerProcedure));
  519.     var oppositeValue = aValue == "false" ? "true" : "false";
  520.     var trueLiteral = gRDF.GetLiteral(oppositeValue);
  521.     var hasCounterpart = this._DS.HasAssertion(handlerSource, handlerProperty, trueLiteral, true);
  522.     if (hasCounterpart) {
  523.       var falseLiteral = gRDF.GetLiteral(aValue);
  524.       this._DS.Change(handlerSource, handlerProperty, trueLiteral, falseLiteral);
  525.     }
  526.   },
  527.   
  528.   get alwaysAsk()
  529.   {
  530.     return this.getHandlerInfoForType(this.URI, "alwaysAsk");
  531.   },
  532.   
  533.   set alwaysAsk(aAlwaysAsk)
  534.   {
  535.     this.changeMIMEStuff(HANDLER_URI(this.mimeType), "alwaysAsk", aAlwaysAsk);
  536.     return aAlwaysAsk;
  537.   },
  538.   
  539.   // helper application
  540.   get appDisplayName()
  541.   {
  542.     return getHelperAppInfoForType(this.URI, "prettyName");
  543.   },
  544.   
  545.   set appDisplayName(aDisplayName)
  546.   {
  547.     this.changeMIMEStuff(APP_URI(this.mimeType), "prettyName", aDisplayName);
  548.     return aDisplayName;
  549.   },
  550.   
  551.   get appPath()
  552.   {
  553.     return this.getHelperAppInfoForType(this.URI, "path");
  554.   },
  555.   
  556.   set appPath(aAppPath)
  557.   {
  558.     this.changeMIMEStuff(APP_URI(this.mimeType), "path", aAppPath);
  559.     return aAppPath;
  560.   },
  561.  
  562.   /**
  563.    * After setting the various properties on this override, we need to
  564.    * build the links between the mime type resource, the handler for that
  565.    * resource, and the helper app (if any) associated with the resource.
  566.    * We also need to add this mime type to the RDF seq (list) of types.
  567.    **/
  568.   buildLinks: function()
  569.   {
  570.     // assert the handler resource
  571.     var mimeSource = gRDF.GetUnicodeResource(MIME_URI(this.mimeType));
  572.     var handlerProperty = gRDF.GetUnicodeResource(NC_URI("handlerProp"));
  573.     var handlerResource = gRDF.GetUnicodeResource(HANDLER_URI(this.mimeType));
  574.     this._DS.Assert(mimeSource, handlerProperty, handlerResource, true);
  575.     // assert the helper app resource
  576.     var helperAppProperty = gRDF.GetUnicodeResource(NC_URI("externalApplication"));
  577.     var helperAppResource = gRDF.GetUnicodeResource(APP_URI(this.mimeType));
  578.     this._DS.Assert(handlerResource, helperAppProperty, helperAppResource, true);
  579.     // add the mime type to the MIME types seq
  580.     var container = Components.classes["@mozilla.org/rdf/container;1"].createInstance();
  581.     if (container) {
  582.       container = container.QueryInterface(Components.interfaces.nsIRDFContainer);
  583.       if (container) {
  584.         var containerRes = gRDF.GetUnicodeResource("urn:mimetypes:root");
  585.         container.Init(this._DS, containerRes);
  586.         var element = gRDF.GetUnicodeResource(MIME_URI(this.mimeType));
  587.         if (container.IndexOf(element) == -1)
  588.           container.AppendElement(element);
  589.       }
  590.     }
  591.   }, 
  592.   
  593.   // Implementation helper methods
  594.   
  595.   getLiteralForContentType: function (aURI, aProperty)
  596.   {
  597.     var contentTypeResource = gRDF.GetUnicodeResource(aURI);
  598.     var propertyResource = gRDF.GetUnicodeResource(NC_URI(aProperty));
  599.     return this.getLiteral(contentTypeResource, propertyResource);
  600.   },
  601.  
  602.   getLiteral: function (aSource, aProperty)
  603.   {
  604.     var node = this._DS.GetTarget(aSource, aProperty, true);
  605.     if (node) {
  606.       node = node.QueryInterface(Components.interfaces.nsIRDFLiteral);
  607.       return node.Value;
  608.     }
  609.     return "";
  610.   },
  611.  
  612.   getHandlerInfoForType: function (aURI, aPropertyString)
  613.   {
  614.     // get current selected type
  615.     var handler = HANDLER_URI(this.getLiteralForContentType(aURI, "value"));
  616.     var source = gRDF.GetUnicodeResource(handler);
  617.     var property = gRDF.GetUnicodeResource(NC_URI(aPropertyString));
  618.     var target = this._DS.GetTarget(source, property, true);
  619.     if (target) {
  620.       target = target.QueryInterface(Components.interfaces.nsIRDFLiteral);
  621.       return target.Value;
  622.     }
  623.     return "";
  624.   },
  625.  
  626.   getHelperAppInfoForType: function (aURI, aPropertyString)
  627.   {
  628.     var appURI      = APP_URI(this.getLiteralForContentType(aURI, "value"));
  629.     var appRes      = gRDF.GetUnicodeResource(appURI);
  630.     var appProperty = gRDF.GetUnicodeResource(NC_URI(aPropertyString));
  631.     return getLiteral(appRes, appProperty);
  632.   },
  633.  
  634.   // write to the ds
  635.   assertMIMEStuff: function (aMIMEString, aPropertyString, aValueString)
  636.   {
  637.     var mimeSource = gRDF.GetUnicodeResource(aMIMEString);
  638.     var valueProperty = gRDF.GetUnicodeResource(NC_URI(aPropertyString));
  639.     var mimeLiteral = gRDF.GetLiteral(aValueString);
  640.     this._DS.Assert(mimeSource, valueProperty, mimeLiteral, true);
  641.   },
  642.  
  643.   changeMIMEStuff: function(aMIMEString, aPropertyString, aValueString)
  644.   {
  645.     var mimeSource = gRDF.GetUnicodeResource(aMIMEString);
  646.     var valueProperty = gRDF.GetUnicodeResource(NC_URI(aPropertyString));
  647.     var mimeLiteral = gRDF.GetLiteral(aValueString);
  648.     var currentValue = this._DS.GetTarget(mimeSource, valueProperty, true);
  649.     if (currentValue) {
  650.       this._DS.Change(mimeSource, valueProperty, currentValue, mimeLiteral);
  651.     } else {
  652.       this._DS.Assert(mimeSource, valueProperty, mimeLiteral, true);
  653.     } 
  654.   },
  655.  
  656.   unassertMIMEStuff: function(aMIMEString, aPropertyString, aValueString)
  657.   {
  658.     var mimeSource = gRDF.GetUnicodeResource(aMIMEString);
  659.     var valueProperty = gRDF.GetUnicodeResource(NC_URI(aPropertyString));
  660.     var mimeLiteral = gRDF.GetLiteral(aValueString);
  661.     this._DS.Unassert(mimeSource, valueProperty, mimeLiteral, true);
  662.   }
  663. };
  664.  
  665.