source: DASISH/t5.6/client/trunk/chrome/markingcollection/content/markingcollection/metacapture.js @ 2711

Last change on this file since 2711 was 2711, checked in by olof, 11 years ago

moved to trunk
File size: 16.7 KB
Line 
1var bitsMetaCapture = {
2        _init : false,
3        _xmlfile : null,
4        _xmldoc  : null,
5
6        get STRING(){ return document.getElementById("MarkingCollectionOverlayString"); },
7
8        get DataSource(){ return window.top.bitsObjectMng.DataSource; },
9        get Common()     { return window.top.bitsObjectMng.Common;     },
10        get Database()   { return window.top.bitsObjectMng.Database;   },
11        get XML()        { return window.top.bitsObjectMng.XML;        },
12        get XPath()      { return window.top.bitsObjectMng.XPath;      },
13        get gBrowser()   { return window.top.bitsObjectMng.getBrowser();},
14
15        get xmldoc()     { return this._xmldoc; },
16        get xmlurl()     { return (this._xmlfile?this.Common.convertFilePathToURL(this._xmlfile.path):""); },
17        get xmlfile()    { return this._xmlfile; },
18
19        get TOKEN_HA()    { return "HYPER_ANCHOR";},
20        get TOKEN_TITLE(){ return "WM_TITLE";},
21        get TOKEN_NOTE()  { return "WM_NOTE";},
22        get TOKEN_META()  { return "WM_META";},
23
24        get TOKEN_MEDLINE_PMCID(){ return "MEDLINE\\.PMCID";},
25        get TOKEN_MEDLINE_PMID()  { return "MEDLINE\\.PMID";},
26        get TOKEN_MEDLINE_SO()    { return "MEDLINE\\.SO";},
27
28/////////////////////////////////////////////////////////////////////
29        init : function(aEvent){
30                if(!this._init){
31                        var extensionDir = this.Common.getExtensionDir().clone();
32                        if(extensionDir){
33                                this._xmlfile = extensionDir.clone();
34                                this._xmlfile.append("metacapture.xml");
35                        }
36                        this._init = true;
37                }
38        },
39
40/////////////////////////////////////////////////////////////////////
41        done : function(aEvent){},
42
43/////////////////////////////////////////////////////////////////////
44        rebuild : function(){
45                if(this._xmlfile){
46                        if(!this._xmlfile.exists()){
47                                var aContent = '<?xml version="1.0" encoding="UTF-8" standalone="yes"?>\n';
48                                aContent += '<!DOCTYPE METACAPTURE>\n';
49                                aContent += '<METACAPTURE>\n';
50                                aContent += '\t<CAPTURE_ITEMS>\n';
51                                aContent += '\t\t<CAPTURE_ITEM tag="TITLE" value="#text"/>\n';
52                                aContent += '\t</CAPTURE_ITEMS>\n';
53                                aContent += '\t<META_REGEXP_ITEMS>\n';
54                                aContent += '\t\t<META_REGEXP_ITEM tag="TITLE" use="true" regexp="" format=""/>\n';
55                                aContent += '\t</META_REGEXP_ITEMS>\n';
56                                aContent += '\t<COPY_ITEMS>\n';
57                                aContent += '\t\t<COPY_ITEM name="hyperanchor" checked="true" selected="false"/>\n';
58                                aContent += '\t\t<COPY_ITEM name="title" checked="true" selected="false"/>\n';
59                                aContent += '\t\t<COPY_ITEM name="note" checked="true" selected="false"/>\n';
60                                aContent += '\t\t<COPY_ITEM name="meta" checked="true" selected="false"/>\n';
61                                aContent += '\t</COPY_ITEMS>\n';
62                                aContent += '\t<OUTPUT_ITEMS>\n';
63                                aContent += '\t\t<OUTPUT_ITEM format="WM_TITLE (WM_META)" regexp="Section (\\d+)/CHAPTER (\\d+)/(.+) from Gray" replace="$1-$2, $3, Gray\'s Anatomy 20th ED" location_hash="true" regexp_i="false" regexp_g="true" regexp_m="false" selected="true"/>\n';
64                                aContent += '\t\t<OUTPUT_ITEM format="WM_TITLE [MEDLINE.SO]" regexp="\\.?\\s*Epub \\d{4} .+]\$" replace="]" location_hash="true" regexp_i="false" regexp_g="true" regexp_m="false"/>\n';
65                                aContent += '\t\t<OUTPUT_ITEM format="WM_TITLE [PMID:MEDLINE.PMID]" regexp="" replace="" location_hash="true" regexp_i="false" regexp_g="true" regexp_m="false"/>\n';
66                                aContent += '\t</OUTPUT_ITEMS>\n';
67                                aContent += '</METACAPTURE>\n';
68                                this.Common.writeFile(this._xmlfile,aContent,"UTF-8");
69                        }
70                        function _loadXMLDocument(pUri){
71                                if(pUri == undefined) return undefined;
72                                var xmlDocument = window.top.bitsMarkingCollection.loadXMLDocument(pUri);
73                                if(xmlDocument){
74                                        return xmlDocument;
75                                }else{
76                                        return undefined;
77                                }
78                        }
79                        function _createXMLDocument(aXMLFile){
80                                if(!aXMLFile) return undefined;
81                                try{
82                                        return _loadXMLDocument(bitsSubstitutionTree.Common.IO.newFileURI(aXMLFile).spec);
83                                }catch(ex){
84                                        bitsSubstitutionTree._dump("bitsSubstitutionTree._createXMLDocument():"+ ex);
85                                        return undefined;
86                                }
87                        }
88                        this._xmldoc = _createXMLDocument(this._xmlfile);
89                }
90        },
91
92/////////////////////////////////////////////////////////////////////
93        xmlflash : function(){
94                if(bitsMetaCapture.xmldoc && bitsMetaCapture._xmlfile){
95                        var s = new XMLSerializer();
96                        var xml = s.serializeToString(bitsMetaCapture.xmldoc);
97                        bitsMetaCapture.Common.writeFile(bitsMetaCapture._xmlfile, xml+"\n","UTF-8");
98                }
99        },
100
101/////////////////////////////////////////////////////////////////////
102// 䞀応互換性の為に定矩しおおく
103/////////////////////////////////////////////////////////////////////
104        copyToClipBoardByHyperanchor : function(aOID,aDBType){
105                this.copyToClipBoard(aOID,aDBType,"copy");
106        },
107
108/////////////////////////////////////////////////////////////////////
109        copyToClipBoard : function(aOID,aDBType,aMode){
110                var obj = bitsMetaCapture.Database.getObject({oid:aOID},aDBType);
111                if(obj && obj.length>0){
112                        var xmldoc = null;
113                        if(aMode == "copy" || aMode == "copyformat" || aMode == "note" || aMode == "meta" || aMode == "format" || aMode == "setting"){
114                                var parser = new DOMParser();
115                                try{ xmldoc = parser.parseFromString(obj[0].oid_property,"text/xml"); }catch(e){xmldoc = null; }
116                                parser = undefined;
117                        }
118                        if(aMode == "copy"){
119                                var copytext = "";
120                                if(xmldoc && xmldoc.documentElement){
121                                        var xmlnode = xmldoc.getElementsByTagName("HYPER_ANCHOR")[0];
122                                        if(xmlnode) copytext = xmlnode.textContent;
123                                        if(!copytext) copytext = obj[0].con_url;
124                                }
125                                this.textToClipBoard(copytext);
126
127                        }else if(aMode == "note"){
128                                var copytext = "";
129                                if(xmldoc && xmldoc.documentElement){
130                                        var xmlnode = xmldoc.getElementsByTagName("NOTE")[0];
131                                        if(xmlnode) copytext = xmlnode.textContent;
132                                }
133                                this.textToClipBoard(copytext);
134
135                        }else if(aMode == "pagetitle"){
136                                this.textToClipBoard(obj[0].doc_title);
137
138                        }else if(aMode == "meta"){
139                                var text_arr = [];
140                                this.rebuild();
141                                var capture_items = this.XPath.evaluateArray('/METACAPTURE[1]/CAPTURE_ITEMS[1]/CAPTURE_ITEM',this.xmldoc);
142                                if(capture_items && capture_items.length > 0){
143                                        var pt_flag = (capture_items.length>1?true:false);
144                                        for(var i=0;i<capture_items.length;i++){
145                                                var tag = capture_items[i].getAttribute("tag");
146                                                if(tag == "TITLE"){
147                                                        text_arr.push((pt_flag?tag+"\t\t":"")+obj[0].doc_title);
148                                                }else{
149                                                        var name = capture_items[i].getAttribute("name");
150                                                        var aExpr;
151                                                        if(name){
152                                                                aExpr = '//METACAPTURE[@tag="'+tag+'" and @name="'+name+'"]';
153                                                        }else{
154                                                                aExpr = '//METACAPTURE[@tag="'+tag+'"]';
155                                                                name = ""
156                                                        }
157                                                        var results = this.XPath.evaluateArray(aExpr,xmldoc);
158                                                        if(results && results.length > 0){
159                                                                for(var j=0;j<results.length;j++){
160                                                                        text_arr.push((pt_flag?tag+"\t"+name+"\t":"")+results[j].getAttribute("content"));
161                                                                }
162                                                        }
163                                                }
164                                        }
165                                }
166                                this.textToClipBoard(text_arr.join("\n"));
167
168                        }else if(aMode == "copytext" || aMode == "title"){
169                                this.textToClipBoard(obj[0].oid_title);
170
171                        }else if(aMode == "format"){
172                                        this.rebuild();
173                                        this.textToClipBoard(this.makeFormatText(this.xmldoc,{
174                                                oid_property : xmldoc,
175                                                doc_title    : obj[0].doc_title,
176                                                oid_title    : obj[0].oid_title,
177                                                con_url      : obj[0].con_url
178                                        }));
179
180                        }else if(aMode == "copyformat" || aMode == "setting"){
181                                setTimeout(function(){
182                                        bitsMetaCapture.rebuild();
183
184                                        var result = {};
185                                        result.accept = false;
186                                        result.xmldoc = bitsMetaCapture.xmldoc;
187                                        result.xmlfile = bitsMetaCapture.xmlfile;
188                                        result.xmlflash = bitsMetaCapture.xmlflash;
189                                        result.makeFormatText = bitsMetaCapture.makeFormatText;
190                                        result.oid_property = xmldoc;
191                                        result.doc_title = obj[0].doc_title;
192                                        result.oid_title = obj[0].oid_title;
193                                        result.con_url = obj[0].con_url;
194                                        window.openDialog("chrome://markingcollection/content/metaCaptureDialog.xul", "", "chrome,centerscreen,modal,dialog,resizable=yes", result);
195                                        if(result.accept){
196                                                bitsMetaCapture.xmlflash();
197                                        }
198                                },0);
199                        }
200                }
201        },
202
203/////////////////////////////////////////////////////////////////////
204        textToClipBoard : function(aText){
205                if(aText){
206                        var str = Components.classes["@mozilla.org/supports-string;1"].createInstance(Components.interfaces.nsISupportsString);
207                        str.data=aText;
208                        var trans = Components.classes["@mozilla.org/widget/transferable;1"].createInstance(Components.interfaces.nsITransferable);
209                        trans.addDataFlavor("text/unicode");
210                        trans.setTransferData("text/unicode",str,aText.length*2);
211                        var clip = Components.classes["@mozilla.org/widget/clipboard;1"].createInstance(Components.interfaces.nsIClipboard);
212                        clip.emptyClipboard(clip.kGlobalClipboard);
213                        clip.setData(trans,null,clip.kGlobalClipboard);
214                }
215        },
216
217/////////////////////////////////////////////////////////////////////
218        makeFormatText : function(aXMLDoc,aData){
219                if(!aXMLDoc || !aData) return "";
220                var setting = {};
221                var format_text = {};
222                var results = this.XPath.evaluateArray('/METACAPTURE[1]/OUTPUT_ITEMS[1]/OUTPUT_ITEM[@selected="true"]',aXMLDoc);
223                if(results && results.length > 0){
224                        setting.format = results[0].getAttribute("format");
225                        setting.regexp = results[0].getAttribute("regexp");
226                        setting.replace = results[0].getAttribute("replace");
227                        setting.location_hash = (results[0].getAttribute("location_hash")=="true"?true:false);
228                        setting.regexp_i = (results[0].getAttribute("regexp_i")=="true"?true:false);
229                        setting.regexp_g = (results[0].getAttribute("regexp_g")=="true"?true:false);
230                        setting.regexp_m = (results[0].getAttribute("regexp_m")=="true"?true:false);
231                }else{
232                        return "";
233                }
234                var results = this.XPath.evaluateArray('/METACAPTURE[1]/OUTPUT_ITEMS[1]',aXMLDoc);
235                if(results && results.length > 0){
236                        setting.anchor_checked = (results[0].getAttribute("anchor_checked")=="true"?true:false);
237                }
238                var value = aData.con_url;
239                var elem = aData.oid_property.getElementsByTagName("HYPER_ANCHOR")[0];
240                if(elem) value = elem.textContent;
241                if(value && setting.location_hash){
242                        var hashReg = new RegExp("^(.+)(#"+bitsHyperAnchorDummy._anchor_title + ")");
243                        try{var textContent = aData.oid_property.getElementsByTagName("LOCATION_HASH")[0].textContent;}catch(e){textContent = "";}
244                        value = value.replace(hashReg,"$1#"+ textContent +"$2");
245                }
246                format_text.hyperanchor = value;
247                if(aData.oid_title){
248                        format_text.title = aData.oid_title;
249                }else{
250                        format_text.title = "";
251                }
252                var value = "";
253                var elem = aData.oid_property.getElementsByTagName("NOTE")[0];
254                if(elem) value = elem.textContent;
255                format_text.note = value;
256                var value = "";
257                var attrs = [];
258                var attrs_hash = {};
259                var regexps = this.XPath.evaluateArray('/METACAPTURE[1]/META_REGEXP_ITEMS[1]/META_REGEXP_ITEM[@use="true"]',aXMLDoc);
260                for(var regcnt=0;regcnt<regexps.length;regcnt++){
261                        var temp_attrs = [];
262                        var nodeName = "tag";
263                        var nodeValue = regexps[regcnt].getAttribute(nodeName);
264                        if(nodeValue != null && nodeValue != "") temp_attrs.push('@'+nodeName+'="'+nodeValue+'"');
265                        var nodeName = "name";
266                        var nodeValue = regexps[regcnt].getAttribute(nodeName);
267                        if(nodeValue != null && nodeValue != "") temp_attrs.push('@'+nodeName+'="'+nodeValue+'"');
268                        if(temp_attrs.length == 0) continue;
269                        var attrs_key = temp_attrs.join(" and ");
270                        if(attrs_hash[attrs_key] == undefined){
271                                attrs.push(attrs_key);
272                                attrs_hash[attrs_key] = [];
273                        }
274                        var temp_attrs = {};
275                        var nodeName = "regexp";
276                        var nodeValue = regexps[regcnt].getAttribute(nodeName);
277                        if(nodeValue != null) temp_attrs[nodeName] = nodeValue;
278                        var nodeName = "format";
279                        var nodeValue = regexps[regcnt].getAttribute(nodeName);
280                        if(nodeValue != null) temp_attrs[nodeName] = nodeValue;
281                        attrs_hash[attrs_key].push(temp_attrs);
282                }
283                for(var regcnt=0;regcnt<attrs.length;regcnt++){
284                        var attrs_key = attrs[regcnt];
285                        if(attrs_key.indexOf('@tag="TITLE"')>=0){
286                                var textContent = aData.doc_title;
287                                for(var rcnt=0;rcnt<attrs_hash[attrs_key].length;rcnt++){
288                                        var regexp = attrs_hash[attrs_key][rcnt].regexp;
289                                        var format = attrs_hash[attrs_key][rcnt].format;
290                                        if(!regexp || regexp == "") continue;
291                                        try{regexp = new RegExp(regexp);}catch(e){regexp=null;}
292                                        if(!regexp) continue;
293                                        if(!textContent.match(regexp)) continue;
294                                        textContent = textContent.replace(regexp,format);
295                                }
296                                value += textContent;
297                        }else{
298                                var nodes = this.XPath.evaluateArray("//METACAPTURE[" + attrs_key + "]",aData.oid_property);
299                                for(var ncnt=0;ncnt<nodes.length;ncnt++){
300                                        var elem = nodes[ncnt];
301                                        var textContent = elem.getAttribute("content");
302                                        if(textContent == null || textContent == "") textContent = elem.textContent;
303                                        for(var rcnt=0;rcnt<attrs_hash[attrs_key].length;rcnt++){
304                                                var regexp = attrs_hash[attrs_key][rcnt].regexp;
305                                                var format = attrs_hash[attrs_key][rcnt].format;
306                                                if(!regexp || regexp == "") continue;
307                                                try{regexp = new RegExp(regexp);}catch(e){regexp=null;}
308                                                if(!regexp) continue;
309                                                if(!textContent.match(regexp)) continue;
310                                                textContent = textContent.replace(regexp,format);
311                                        }
312                                        value += textContent;
313                                }
314                        }
315                }
316                format_text.meta = value;
317                format_text.medline = {};
318                var value = "";
319                var elem = aData.oid_property.getElementsByTagName("PMCID")[0];
320                if(elem) value = elem.textContent;
321                format_text.medline.pmcid = value;
322                var value = "";
323                var elem = aData.oid_property.getElementsByTagName("PMID")[0];
324                if(elem) value = elem.textContent;
325                format_text.medline.pmid = value;
326                var value = "";
327                var elem = aData.oid_property.getElementsByTagName("SO")[0];
328                if(elem) value = elem.textContent;
329                format_text.medline.so = value;
330                var output = setting.format;
331                var flag = "";
332                flag += (setting.regexp_i?'i':'');
333                flag += (setting.regexp_g?'g':'');
334                flag += (setting.regexp_m?'m':'');
335                try{var regexp = (setting.regexp?new RegExp(setting.regexp,flag):null);}catch(e){this._dump(e);}
336                var replace_text = setting.replace;
337                var replacement_key = null;
338                replacement_key = new RegExp(bitsMetaCapture.TOKEN_HA,'g');
339                output = output.replace(replacement_key,format_text.hyperanchor);
340                replacement_key = new RegExp(bitsMetaCapture.TOKEN_TITLE,'g');
341                output = output.replace(replacement_key,format_text.title);
342                replacement_key = new RegExp(bitsMetaCapture.TOKEN_NOTE,'g');
343                output = output.replace(replacement_key,format_text.note);
344                replacement_key = new RegExp(bitsMetaCapture.TOKEN_META,'g');
345                output = output.replace(replacement_key,format_text.meta);
346                replacement_key = new RegExp(bitsMetaCapture.TOKEN_MEDLINE_PMCID,'g');
347                output = output.replace(replacement_key,format_text.medline.pmcid);
348                replacement_key = new RegExp(bitsMetaCapture.TOKEN_MEDLINE_PMID,'g');
349                output = output.replace(replacement_key,format_text.medline.pmid);
350                replacement_key = new RegExp(bitsMetaCapture.TOKEN_MEDLINE_SO,'g');
351                output = output.replace(replacement_key,format_text.medline.so);
352                if(regexp && output.match(regexp)) output = output.replace(regexp,replace_text);
353                if(setting.anchor_checked) output = '<a href="'+format_text.hyperanchor+'">'+output+'</a>';
354                output = output.replace(/\\n/g,"\n");
355                return output;
356        },
357
358/////////////////////////////////////////////////////////////////////
359        capture : function(aDoc,aProperty){
360                var confirm = nsPreferences.getBoolPref("wiredmarker.meta.capture.confirm", true);
361                if(!confirm) return aProperty;
362                this.rebuild();
363                var capture_items = this.XPath.evaluateArray('/METACAPTURE[1]/CAPTURE_ITEMS[1]/CAPTURE_ITEM[@tag!="TITLE"]',this.xmldoc);
364                if(!capture_items || capture_items.length == 0) return aProperty;
365                if(!aProperty || aProperty == "") aProperty = "<PROPERTY/>";
366                var parser = new DOMParser();
367                var xmldoc = parser.parseFromString(aProperty,"text/xml");
368                var extnode = null
369                var results = this.XPath.evaluateArray('//EXTENDED_MESSAGE',xmldoc);
370                if(!results || results.length == 0){
371                        extnode = xmldoc.createElement("EXTENDED_MESSAGE");
372                        xmldoc.documentElement.appendChild(extnode);
373                }else{
374                        extnode = results[0];
375                }
376                var metanodes = null;
377                var results = this.XPath.evaluateArray('//METACAPTURES',xmldoc);
378                if(!results || results.length == 0){
379                        metanodes = xmldoc.createElement("METACAPTURES");
380                        extnode.appendChild(metanodes);
381                }else{
382                        metanodes = results[0];
383                }
384                for(var i=0;i<capture_items.length;i++){
385                        var tag = capture_items[i].getAttribute("tag");
386                        var name = capture_items[i].getAttribute("name");
387                        var value = capture_items[i].getAttribute("value");
388                        if(!value) value = "#text";
389                        var aExpr = '//'+tag.toLowerCase();
390                        if(name) aExpr += '[@name="'+name+'"]';
391                        var results = this.XPath.evaluateArray(aExpr,aDoc);
392                        if(results && results.length > 0){
393                                for(var j=0;j<results.length;j++){
394                                        var metanode = xmldoc.createElement("METACAPTURE");
395                                        metanode.setAttribute("tag",tag);
396                                        if(name) metanode.setAttribute("name",name);
397                                        metanode.setAttribute("content",(value=="#text"?results[j].textContent:results[j].getAttribute(value)));
398                                        metanodes.appendChild(metanode);
399                                }
400                        }
401                }
402                var s = new XMLSerializer();
403                return s.serializeToString(xmldoc);
404        },
405
406/////////////////////////////////////////////////////////////////////
407        _dump : function(aString){
408                window.top.bitsMarkingCollection._dump(aString);
409        },
410}
Note: See TracBrowser for help on using the repository browser.