# HG changeset patch
# User engler
# Date 1056548378 -7200
# Node ID bf6d9b7a77d4c30f7925ba3b3c7154c827e43741
# Parent 6d30311f772b9004bc5ba9854653cdfc0d9e6dd6
Annotation Tool to integrate in chrome sidebar
diff -r 6d30311f772b -r bf6d9b7a77d4 xul/annota/annota.js
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/xul/annota/annota.js Wed Jun 25 15:39:38 2003 +0200
@@ -0,0 +1,319 @@
+include ('chrome://jslib/content/io/dir.js');
+include ('chrome://jslib/content/io/file.js');
+include ('chrome://jslib/content/io/rdfBase.js');
+include ('chrome://jslib/content/io/rdfResource.js');
+include ('chrome://jslib/content/io/rdfContainer.js');
+include ('chrome://jslib/content/io/rdf.js');
+include ('chrome://jslib/content/io/rdfFile.js');
+include('chrome://jslib/content/io/fileUtils.js');
+
+var slash='/';
+if (navigator.platform=="Win32"){
+ slash='\\';
+}
+
+var directory=slash;
+var digilib_path=slash;
+
+getProfile();
+
+function makePathCompatible(path){
+ if (navigator.platform=="Win32"){
+ // slash durch backslash ersetzten
+ path=path.replace(/\//g,"\\");
+ // nur 2 backslashs am anfang
+ path=path.replace(/^\\{3}/,"\\\\");
+ // vor Laufwerkbuchstaben kein Backslash
+ if (path.indexOf(":")>0){
+ path=path.replace(/^\\/g,"");
+ }
+ // nur ein Slash gibt Absturz
+ path=path.replace(/^\\$/,"c:\\");
+ //alert(path);
+ }
+ return path;
+}
+
+function file_open(){
+ var nsIFilePicker = Components.interfaces.nsIFilePicker;
+ var fp = Components.classes["@mozilla.org/filepicker;1"]
+ .createInstance(nsIFilePicker);
+ fp.init(window, "Select a Directory", nsIFilePicker.modeGetFolder);
+
+ // set default direcotry
+ var aLocalFile = Components.classes["@mozilla.org/file/local;1"].createInstance(Components.interfaces.nsILocalFile);
+ directory=makePathCompatible(directory);
+ aLocalFile.initWithPath(directory);
+ fp.displayDirectory=aLocalFile;
+
+ var res=fp.show();
+ if (res==nsIFilePicker.returnOK){
+ directory=fp.fileURL.path;
+ directory=makePathCompatible(directory);
+ setTreeDirectory();
+ }
+}
+
+function setTreeDirectory(){
+ var t=document.getElementById("file_tree");
+ t.setAttribute("ref","file://"+directory);
+}
+
+function refreshTree(){
+ var t=document.getElementById("file_tree");
+ t.builder.rebuild();
+}
+
+function file_save(){
+
+ // get Digilib-Parameter form Browser
+ // alert(window.content.location.href);
+
+ var documentpath='';
+ try{
+ documentpath=window.content.getParameter('fn');
+ }catch (e){
+ documentpath='';
+ }
+ if (documentpath != ''){
+ var docPath='urn:echo:'+documentpath;
+
+ var rdfString='' +
+ '' +
+ ' ' +
+ ' ' +
+ ' ' +
+ ' '+
+ '';
+
+ var ds=new RDFDataSource();
+ ds.parseFromString(rdfString,"http://echo.unibe.ch/digilib/rdf/digilib.rdf");
+ var node=ds.getNode(docPath);
+ var arrayParams=window.content.listParameters();
+ for (i=0; i< arrayParams.length; i++){
+ var value=window.content.getParameter(arrayParams[i]);
+ //alert(arrayParams[i]+":"+value);
+ node.addTarget("http://echo.unibe.ch/digilib/rdf#"+arrayParams[i],value);
+ }
+ node.addTarget("http://echo.unibe.ch/digilib/rdf#lv","1");
+ //alert(ds.serializeToString());
+ var nsIFilePicker = Components.interfaces.nsIFilePicker;
+ var fp = Components.classes["@mozilla.org/filepicker;1"]
+ .createInstance(nsIFilePicker);
+ fp.init(window, "Select a File", nsIFilePicker.modeSave);
+
+ // set default direcotry
+ var aLocalFile = Components.classes["@mozilla.org/file/local;1"].createInstance(Components.interfaces.nsILocalFile);
+ directory=makePathCompatible(directory);
+ aLocalFile.initWithPath(directory);
+ fp.displayDirectory=aLocalFile;
+
+ fp.appendFilter("Annotations","*.rdf; *.RDF");
+ var res=fp.show();
+ if (res==nsIFilePicker.returnOK){
+ var thefile=fp.file;
+ // --- do something with the file here ---
+ //alert(fp.file);
+ //alert(fp.fileURL.path);
+
+ var strFilePath=fp.file.path;
+ strFilePath=strFilePath.toLowerCase();
+ if (strFilePath.indexOf('.rdf')<0){
+ strFilePath=fp.fileURL.path+".rdf";
+ }else{
+ strFilePath=fp.fileURL.path;
+ }
+ strFilePath=makePathCompatible(strFilePath);
+ var f=new File(strFilePath);
+ //var boolFileExists=f.exists();
+ //alert(boolFileExists);
+ f.create();
+ f.open('w');
+ f.write(ds.serializeToString());
+ f.close();
+ refreshTree();
+ }
+ }else{
+ alert("Error: no alcatraz component. can't create an annotation.");
+ }
+}
+
+function file_local(){
+ // noch nicht programmiert
+}
+
+function file_annotaDB(){
+ alert("At the moment it is not possible to use the annota DB! This feature is not yet programmed.");
+ var menu_item=document.getElementById('local');
+ menu_item.setAttribute('checked','true');
+}
+
+function tree_click(){
+ var t=document.getElementById("file_tree"); //tree element
+ var l=t.view.getItemAtIndex(t.currentIndex); //aus baum treeitem herausholen mit dem selected index (currentIndex)
+ //l.firstChild ist treeitem
+ var d=l.firstChild.firstChild; //treecell
+ var firstLabel=d.getAttribute("label");
+ var cols=document.getElementById("cols");
+ var col=cols.childNodes;
+ var nodes=l.firstChild.childNodes;
+ var rdf_file="";
+ for (var i=0;i
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff -r 6d30311f772b -r bf6d9b7a77d4 xul/annota/rdfds.js
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/xul/annota/rdfds.js Wed Jun 25 15:39:38 2003 +0200
@@ -0,0 +1,760 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ * The contents of this file are subject to the Mozilla Public
+ * License Version 1.1 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *
+ * The Original Code is rdfds
+ *
+ * The Initial Developer of the Original Code is Neil Deakin
+ * Portions created by Neil Deakin are Copyright (C) 2002 Neil Deakin.
+ * All Rights Reserved.
+ *
+ * Contributor(s):
+ */
+
+/* This is a library for easier access to RDF datasources and resources.
+ * It contains four objects, RDFDataSource, RDFNode, RDFLiteral. and
+ * RDFEnumerator.
+ *
+ * An RDF DataSource is a graph of nodes and literals. The constructor
+ * for RDFDataSource takes one argument, a URI of an RDF file to use.
+ * If the URI exists, the contents of the RDF file are loaded. If it
+ * does not exist, resources can be added to it and then written using
+ * this save method. If the URL argument is null, a blank datasource
+ * is created.
+ *
+ * This library is designed for convenience not for efficiency.
+ *
+ * The API is documented at:
+ * http://www.xulplanet.com/tutorials/xultu/rdfds/
+ *
+ * Example:
+ *
+ * var ds=new RDFDataSource("file:///main/mozilla/mimtest.rdf");
+ * var node=ds.getNode("urn:xpimaker:packlist");
+ * var child=ds.getNode("urn:xpimaker:packlist:appinfo");
+ * child=node.addChild(child);
+ * child.addTarget("http://www.xulplanet.com/rdf/xpimaker#appname","Find Files");
+ * ds.save();
+ *
+ */
+
+var RDFService = "@mozilla.org/rdf/rdf-service;1";
+RDFService = Components.classes[RDFService].getService();
+RDFService = RDFService.QueryInterface(Components.interfaces.nsIRDFService);
+
+var RDFContainerUtilsService = "@mozilla.org/rdf/container-utils;1";
+RDFContainerUtilsService = Components.classes[RDFContainerUtilsService].getService();
+RDFContainerUtilsService = RDFContainerUtilsService.QueryInterface(Components.interfaces.nsIRDFContainerUtils);
+
+/* RDFLoadObserver
+ * this object is necessary to listen to RDF files being loaded. The Init
+ * function should be called to initialize the callback when the RDF file is
+ * loaded.
+ */
+function RDFLoadObserver(){}
+
+RDFLoadObserver.prototype =
+{
+ callback: null,
+ callbackDataSource: null,
+
+ Init: function(c,cDS){
+ this.callback=c;
+ this.callbackDataSource=cDS;
+ },
+
+ QueryInterface: function(iid){
+ if (iid.equals(Components.interfaces.nsIRDFXMLSinkObserver)) return this;
+ else throw Components.results.NS_ERROR_NO_INTERFACE;
+ },
+
+ onBeginLoad : function(sink){},
+ onInterrupt : function(sink){},
+ onResume : function(sink){},
+ onError : function(sink,status,msg){},
+
+ onEndLoad : function(sink){
+ if (this.callback!=null) this.callback(this.callbackDataSource);
+ }
+};
+
+function RDFDataSource(uri,callbackFn)
+{
+ if (uri==null) this.datasource=null;
+ else this.load(uri,callbackFn);
+}
+
+RDFDataSource.prototype.load=
+ function(uri,callbackFn)
+{
+ if (uri.indexOf(":") == -1){
+ var docurl=document.location.href;
+ if (document.location.pathname == null) uri=docurl+"/"+uri;
+ else uri=docurl.substring(0,docurl.lastIndexOf("/")+1)+uri;
+ }
+
+ if (callbackFn == null){
+ this.datasource=RDFService.GetDataSourceBlocking(uri);
+ }
+ else {
+ this.datasource=RDFService.GetDataSource(uri);
+ var ds;
+ try {
+ var ds=this.datasource.QueryInterface(Components.interfaces.nsIRDFRemoteDataSource);
+ }
+ catch (ex){
+ callbackFn(this);
+ return;
+ }
+ if (ds.loaded){
+ callbackFn(this);
+ return;
+ }
+
+ var packObserver=new RDFLoadObserver();
+ packObserver.Init(callbackFn,this);
+
+ var rawsource=this.datasource;
+ rawsource=rawsource.QueryInterface(Components.interfaces.nsIRDFXMLSink);
+ rawsource.addXMLSinkObserver(packObserver);
+ }
+}
+
+RDFDataSource.prototype.Init=
+ function (dsource)
+{
+ this.datasource=dsource;
+}
+
+RDFDataSource.prototype.parseFromString=
+ function (str,baseUri)
+{
+ if (this.datasource==null) this.makeemptyds();
+ var ios=Components.classes["@mozilla.org/network/io-service;1"]
+ .getService(Components.interfaces.nsIIOService);
+ baseUri=ios.newURI(baseUri,null,null);
+ var xmlParser=Components.classes["@mozilla.org/rdf/xml-parser;1"]
+ .createInstance(Components.interfaces.nsIRDFXMLParser);
+ xmlParser.parseString(this.datasource,baseUri,str);
+}
+
+RDFDataSource.prototype.serializeToString=
+ function ()
+{
+ var outputStream = {
+ data: "",
+ close : function(){},
+ flush : function(){},
+ write : function (buffer,count){
+ this.data += buffer;
+ return count;
+ },
+ writeFrom : function (stream,count){},
+ isNonBlocking: false
+ }
+ this.serializeToStream(outputStream);
+ return outputStream.data;
+}
+
+RDFDataSource.prototype.serializeToStream=
+ function (outputStream)
+{
+ var ser=Components.classes["@mozilla.org/rdf/xml-serializer;1"]
+ .createInstance(Components.interfaces.nsIRDFXMLSerializer);
+ ser.init(this.datasource);
+ ser.QueryInterface(Components.interfaces.nsIRDFXMLSource).Serialize(outputStream);
+}
+
+RDFDataSource.prototype.makeemptyds=
+ function (uri)
+{
+ this.datasource=Components.classes["@mozilla.org/rdf/datasource;1?name=in-memory-datasource"]
+ .createInstance(Components.interfaces.nsIRDFDataSource);
+}
+
+RDFDataSource.prototype.getAllResources=
+ function ()
+{
+ if (this.datasource==null) return null;
+ return new RDFEnumerator(this.datasource.GetAllResources(),this.datasource);
+}
+
+RDFDataSource.prototype.getRawDataSource=
+ function ()
+{
+ if (this.datasource==null) this.makeemptyds();
+ return this.datasource;
+}
+
+RDFDataSource.prototype.getNode=
+ function (uri)
+{
+ if (this.datasource==null) this.makeemptyds();
+ var node=new RDFNode(uri,this);
+ return node;
+}
+
+RDFDataSource.prototype.getAnonymousNode=
+ function ()
+{
+ if (this.datasource==null) this.makeemptyds();
+
+ var anon=RDFService.GetAnonymousResource();
+ var node=new RDFNode();
+ node.Init(anon,this.datasource);
+ return node;
+}
+
+RDFDataSource.prototype.getLiteral=
+ function (uri)
+{
+ if (this.datasource==null) this.makeemptyds();
+
+ return new RDFLiteral(uri,this);
+}
+
+RDFDataSource.prototype.refresh=
+ function (sync)
+{
+ try {
+ var ds=this.datasource.QueryInterface(Components.interfaces.nsIRDFRemoteDataSource);
+ ds.Refresh(sync);
+ return true;
+ }
+ catch (ex){
+ return false;
+ }
+}
+
+RDFDataSource.prototype.save=
+ function ()
+{
+ try {
+ var ds=this.datasource.QueryInterface(Components.interfaces.nsIRDFRemoteDataSource);
+ ds.Flush();
+ return true;
+ }
+ catch (ex){
+ return false;
+ }
+}
+
+RDFDataSource.prototype.copyAllToDataSource=
+ function (dsource2)
+{
+ if (this.datasource==null) this.makeemptyds();
+ if (dsource2.datasource==null) dsource2.makeemptyds();
+
+ var dsource1=this.datasource;
+ dsource2=dsource2.datasource;
+
+ var sourcelist=dsource1.GetAllResources();
+ while(sourcelist.hasMoreElements()){
+ var source=sourcelist.getNext();
+ var props=dsource1.ArcLabelsOut(source);
+ while(props.hasMoreElements()){
+ var prop=props.getNext();
+ prop=prop.QueryInterface(Components.interfaces.nsIRDFResource);
+ var target=dsource1.GetTarget(source,prop,true);
+ if (target!=null) dsource2.Assert(source,prop,target,true);
+ }
+ }
+}
+
+RDFDataSource.prototype.deleteRecursive=
+ function (val)
+{
+ var node;
+ var dsource=this.datasource;
+
+ if (dsource==null) return;
+
+ if (typeof val == "string") node=RDFService.GetResource(val);
+ else node=val.source;
+
+ this.deleteRecursiveH(dsource,node); // remove descendants
+
+ // remove the node itself
+ var props=dsource.ArcLabelsIn(node);
+ while(props.hasMoreElements()){
+ var prop=props.getNext();
+ var source=dsource.GetSource(prop,node,true);
+ dsource.Unassert(source,prop,node);
+ }
+}
+
+RDFDataSource.prototype.deleteRecursiveH=
+ function (dsource,node)
+{
+ var props=dsource.ArcLabelsOut(node);
+ while(props.hasMoreElements()){
+ var prop=props.getNext();
+ var target=dsource.GetTarget(node,prop,true);
+ try {
+ target=target.QueryInterface(Components.interfaces.nsIRDFResource);
+ this.deleteRecursiveH(dsource,target);
+ }
+ catch (e){}
+ dsource.Unassert(node,prop,target)
+ }
+}
+
+function RDFNode(uri,dsource)
+{
+ if (uri==null) this.source=null;
+ else this.source=RDFService.GetResource(uri);
+
+ if (dsource==null) this.datasource=null;
+ else this.datasource=dsource.datasource;
+
+ this.container=null;
+}
+
+RDFNode.prototype.Init=
+ function (source,dsource)
+{
+ this.source=source;
+ this.datasource=dsource;
+ this.container=null;
+}
+
+RDFNode.prototype.getValue=
+ function ()
+{
+ return this.source.Value;
+}
+
+RDFNode.prototype.rlify=
+ function (val)
+{
+ var res=null;
+
+ if (val!=null){
+ try {
+ val=val.QueryInterface(Components.interfaces.nsIRDFResource);
+ res=new RDFNode();
+ res.Init(val,this.datasource);
+ }
+ catch (ex){
+ try {
+ val=val.QueryInterface(Components.interfaces.nsIRDFLiteral);
+ res=new RDFLiteral();
+ res.Init(val,this.datasource);
+ }
+ catch (ex2){
+ }
+ }
+ }
+ return res;
+}
+
+RDFNode.prototype.makeres=
+ function (val)
+{
+ if (typeof val == "string") return RDFService.GetResource(val);
+ else return val.source;
+}
+
+RDFNode.prototype.makelit=
+ function (val)
+{
+ if (typeof val == "string") return RDFService.GetLiteral(val);
+ else return val.source;
+}
+
+RDFNode.prototype.makecontain=
+ function ()
+{
+ if (this.container!=null) return true;
+
+ var RDFContainer = '@mozilla.org/rdf/container;1';
+ RDFContainer = Components.classes[RDFContainer].createInstance();
+ RDFContainer = RDFContainer.QueryInterface(Components.interfaces.nsIRDFContainer);
+
+ try {
+ RDFContainer.Init(this.datasource,this.source);
+ this.container=RDFContainer;
+ return true;
+ }
+ catch (ex){
+ return false;
+ }
+}
+
+RDFNode.prototype.addTarget=
+ function (prop,target)
+{
+ prop=this.makeres(prop);
+ target=this.makelit(target);
+ this.datasource.Assert(this.source,prop,target,true);
+}
+
+RDFNode.prototype.addTargetOnce=
+ function (prop,target)
+{
+ prop=this.makeres(prop);
+ target=this.makelit(target);
+
+ var oldtarget=this.datasource.GetTarget(this.source,prop,true);
+ if (oldtarget!=null){
+ this.datasource.Change(this.source,prop,oldtarget,target);
+ }
+ else {
+ this.datasource.Assert(this.source,prop,target,true);
+ }
+}
+
+RDFNode.prototype.modifyTarget=
+ function (prop,oldtarget,newtarget)
+{
+ prop=this.makeres(prop);
+ oldtarget=this.makelit(oldtarget);
+ newtarget=this.makelit(newtarget);
+ this.datasource.Change(this.source,prop,oldtarget,newtarget);
+}
+
+RDFNode.prototype.modifySource=
+ function (prop,oldsource,newsource)
+{
+ prop=this.makeres(prop);
+ oldsource=this.makeres(oldsource);
+ newsource=this.makeres(newsource);
+ this.datasource.Move(oldsource,newsource,prop,this.source);
+}
+
+RDFNode.prototype.targetExists=
+ function (prop,target)
+{
+ prop=this.makeres(prop);
+ target=this.makelit(target);
+ return this.datasource.HasAssertion(this.source,prop,target,true);
+}
+
+RDFNode.prototype.removeTarget=
+ function (prop,target)
+{
+ prop=this.makeres(prop);
+ target=this.makelit(target);
+ this.datasource.Unassert(this.source,prop,target);
+}
+
+RDFNode.prototype.getProperties=
+ function ()
+{
+ return new RDFEnumerator(this.datasource.ArcLabelsOut(this.source),this.datasource);
+}
+
+RDFNode.prototype.getInProperties=
+ function ()
+{
+ return new RDFEnumerator(this.datasource.ArcLabelsIn(this.source),this.datasource);
+}
+
+RDFNode.prototype.propertyExists=
+ function (prop)
+{
+ prop=this.makeres(prop);
+ return this.datasource.hasArcOut(this.source,prop);
+}
+
+RDFNode.prototype.inPropertyExists=
+ function (prop)
+{
+ prop=this.makeres(prop);
+ return this.datasource.hasArcIn(this.source,prop);
+}
+
+RDFNode.prototype.getTarget=
+ function (prop)
+{
+ prop=this.makeres(prop);
+ return this.rlify(this.datasource.GetTarget(this.source,prop,true));
+}
+
+RDFNode.prototype.getSource=
+ function (prop)
+{
+ prop=this.makeres(prop);
+ var src=this.datasource.GetSource(prop,this.source,true);
+ if (src==null) return null;
+ var res=new RDFNode();
+ res.Init(src,this.datasource);
+ return res;
+}
+
+RDFNode.prototype.getTargets=
+ function (prop)
+{
+ prop=this.makeres(prop);
+ return new RDFEnumerator(
+ this.datasource.GetTargets(this.source,prop,true),this.datasource);
+}
+
+RDFNode.prototype.getSources=
+ function (prop)
+{
+ prop=this.makeres(prop);
+ return new RDFEnumerator(
+ this.datasource.GetSources(prop,this.source,true),this.datasource);
+}
+
+RDFNode.prototype.makeBag=
+ function ()
+{
+ this.container=RDFContainerUtilsService.MakeBag(this.datasource,this.source);
+}
+
+RDFNode.prototype.makeSeq=
+ function ()
+{
+ this.container=RDFContainerUtilsService.MakeSeq(this.datasource,this.source);
+}
+
+RDFNode.prototype.makeAlt=
+ function ()
+{
+ this.container=RDFContainerUtilsService.MakeAlt(this.datasource,this.source);
+}
+
+RDFNode.prototype.isBag=
+ function ()
+{
+ return RDFContainerUtilsService.isBag(this.datasource,this.source);
+}
+
+RDFNode.prototype.isSeq=
+ function ()
+{
+ return RDFContainerUtilsService.isSeq(this.datasource,this.source);
+}
+
+RDFNode.prototype.isAlt=
+ function ()
+{
+ return RDFContainerUtilsService.isAlt(dsource,this.source);
+}
+
+RDFNode.prototype.isContainer=
+ function ()
+{
+ return RDFContainerUtilsService.IsContainer(this.datasource,this.source);
+}
+
+RDFNode.prototype.getChildCount=
+ function ()
+{
+ if (this.makecontain()){
+ return this.container.GetCount();
+ }
+ return -1;
+}
+
+RDFNode.prototype.getChildren=
+ function ()
+{
+ if (this.makecontain()){
+ return new RDFEnumerator(this.container.GetElements(),this.datasource);
+ }
+ else return null;
+}
+
+RDFNode.prototype.addChild=
+ function (child,exists)
+{
+ if (this.makecontain()){
+ var childres=null;
+ if (typeof child == "string"){
+ childres=RDFService.GetResource(child);
+ child=new RDFNode();
+ child.Init(childres,this.datasource);
+ }
+ else childres=child.source;
+
+ if (!exists && this.container.IndexOf(childres)>=0) return child;
+
+ this.container.AppendElement(childres);
+ return child;
+ }
+ else return null;
+}
+
+RDFNode.prototype.addChildAt=
+ function (child,idx)
+{
+ if (this.makecontain()){
+ var childres=null;
+ if (typeof child == "string"){
+ childres=RDFService.GetResource(child);
+ child=new RDFNode();
+ child.Init(childres,this.datasource);
+ }
+ else childres=child.source;
+ this.container.InsertElementAt(childres,idx,true);
+ return child;
+ }
+ else return null;
+}
+
+RDFNode.prototype.removeChild=
+ function (child)
+{
+ if (this.makecontain()){
+ var childres=null;
+ if (typeof child == "string"){
+ childres=RDFService.GetResource(child);
+ child=new RDFNode();
+ child.Init(childres,this.datasource);
+ }
+ else childres=child.source;
+ this.container.RemoveElement(childres,true);
+ return child;
+ }
+ else return null;
+}
+
+RDFNode.prototype.removeChildAt=
+ function (idx)
+{
+ if (this.makecontain()){
+ var childres=this.container.RemoveElementAt(idx,true);
+ return this.rlify(childres);
+ }
+ else return null;
+}
+
+RDFNode.prototype.getChildIndex=
+ function (child)
+{
+ if (this.makecontain()){
+ return this.container.IndexOf(child.source);
+ }
+ else return -1;
+}
+
+RDFNode.prototype.type="Node";
+
+
+function RDFLiteral(val,dsource)
+{
+ if (val==null) this.source=null;
+ else this.source=RDFService.GetLiteral(val);
+
+ if (dsource==null) this.datasource=null;
+ else this.datasource=dsource.datasource;
+}
+
+RDFLiteral.prototype.Init=
+ function (source,dsource)
+{
+ this.source=source;
+ this.datasource=dsource;
+}
+
+RDFLiteral.prototype.getValue=
+ function ()
+{
+ return this.source.Value;
+}
+
+RDFLiteral.prototype.makeres=
+ function (val)
+{
+ if (typeof val == "string") return RDFService.GetResource(val);
+ else return val.source;
+}
+
+RDFLiteral.prototype.makelit=
+ function (val)
+{
+ if (typeof val == "string") return RDFService.GetLiteral(val);
+ else return val.source;
+}
+
+RDFLiteral.prototype.modifySource=
+ function (prop,oldsource,newsource)
+{
+ prop=this.makeres(prop);
+ oldsource=this.makeres(oldsource);
+ newsource=this.makeres(newsource);
+ this.datasource.Move(oldsource,newsource,prop,this.source);
+}
+
+RDFLiteral.prototype.getInProperties=
+ function (prop)
+{
+ return new RDFEnumerator(this.datasource.ArcLabelsIn(this.source),this.datasource);
+}
+
+RDFLiteral.prototype.inPropertyExists=
+ function (prop)
+{
+ prop=this.makeres(prop);
+ return this.datasource.hasArcIn(this.source,prop);
+}
+
+RDFLiteral.prototype.getSource=
+ function (prop)
+{
+ prop=this.makeres(prop);
+ var src=this.datasource.GetSource(prop,this.source,true);
+ if (src==null) return null;
+ var res=new RDFNode();
+ res.Init(src,this.datasource);
+ return res;
+}
+
+RDFLiteral.prototype.getSources=
+ function (prop)
+{
+ prop=this.makeres(prop);
+ return new RDFEnumerator(
+ this.datasource.GetSources(prop,this.source,true),this.datasource);
+}
+
+RDFLiteral.prototype.type="Literal";
+
+
+function RDFEnumerator(enumeration,dsource)
+{
+ this.enumeration=enumeration;
+ this.datasource=dsource;
+}
+
+RDFEnumerator.prototype.hasMoreElements=
+ function ()
+{
+ return this.enumeration.hasMoreElements();
+}
+
+RDFEnumerator.prototype.getNext=
+ function ()
+{
+ var res=null;
+ var val=this.enumeration.getNext();
+
+ if (val!=null){
+ try {
+ val=val.QueryInterface(Components.interfaces.nsIRDFResource);
+ res=new RDFNode();
+ res.Init(val,this.datasource);
+ }
+ catch (ex){
+ try {
+ val=val.QueryInterface(Components.interfaces.nsIRDFLiteral);
+ res=new RDFLiteral();
+ res.Init(val,this.datasource);
+ }
+ catch (ex2){
+ }
+ }
+ }
+ return res;
+}
+
diff -r 6d30311f772b -r bf6d9b7a77d4 xul/annota/tools_dialog.xul
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/xul/annota/tools_dialog.xul Wed Jun 25 15:39:38 2003 +0200
@@ -0,0 +1,29 @@
+
+
+
+
+