diff --git a/chrome/content/zotero/bindings/styled-textbox.xml b/chrome/content/zotero/bindings/styled-textbox.xml
index d1c6821312..ad6bc4f15b 100644
--- a/chrome/content/zotero/bindings/styled-textbox.xml
+++ b/chrome/content/zotero/bindings/styled-textbox.xml
@@ -60,15 +60,30 @@
"":"\\b ",
"":"\\b0 ",
"
":"\x0B",
- "":"\\super ",
- "":"\\super0 ",
- "":"\\sub ",
- "":"\\sub0 ",
// there's no way to mimic a tab stop in CSS without
// tables, which wouldn't work here.
- ' ':"\t"
+ ' ':"\\tab "
};
+ this._rtfToHtmlMap = [
+ [/\\uc0\{?\\u([0-9]+)\}? ?/g, function(wholeStr, aCode) { return String.fromCharCode(aCode) }],
+ ["\\t ", ' '],
+ [/(?:\\par |\\\r?\n)/g, ""],
+ [/\\super (.*?)\\nosupersub /g, "$1"],
+ [/\\sub (.*?)\\nosupersub /g, "$1"],
+ ];
+
+ this._htmlToRtfMap = [
+ [/[\x7F-\uFFFF]/g, function(aChar) { return "\\uc0\\u"+aChar.charCodeAt(0).toString()+" " }],
+ ["
", ""],
+ ["
", "\\par "],
+ [/<\/?div[^>]*>/g, ""],
+ ["", "\\super "],
+ ["", "\\nosupersub "],
+ ["", "\\sub "],
+ ["", "\\nosupersub "],
+ ];
+
this._rtfRexMap = [
["",
/small-caps/,
@@ -117,7 +132,6 @@
break;
case 'change':
- Zotero.debug("Event type is " + event.type);
break;
default:
@@ -163,16 +177,9 @@
", "", "g");
- output = output.replace("", "\\par ", "g");
- output = output.replace(/<\/?div[^>]*>/g, "");
+ for each(var entry in this._htmlToRtfMap) {
+ output = output.replace(entry[0], entry[1], "g");
+ }
output = Zotero.Utilities.prototype.trim(output);
output = output.replace(" ", " ", "g");
output = Zotero.Utilities.prototype.unescapeHTML(output);
@@ -213,8 +220,6 @@
return output;
]]>
", "g");
}
- html = ''+html.replace("\par ", "
")+"
\n",
+ "bibend": "
",
+ "@font-style/italic": "%%STRING%%",
+ "@font-style/oblique": "%%STRING%%",
+ "@font-style/normal": "%%STRING%%",
+ "@font-variant/small-caps": "%%STRING%%",
+ "@passthrough/true": CSL.Output.Formatters.passthrough,
+ "@font-variant/normal": false,
+ "@font-weight/bold": "%%STRING%%",
+ "@font-weight/normal": "%%STRING%%",
+ "@font-weight/light": false,
+ "@text-decoration/none": "%%STRING%%",
+ "@text-decoration/underline": "%%STRING%%",
+ "@vertical-align/sup": "%%STRING%%",
+ "@vertical-align/sub": "%%STRING%%",
+ "@vertical-align/baseline": "%%STRING%%",
+ "@strip-periods/true": CSL.Output.Formatters.strip_periods,
+ "@strip-periods/false": function (state, string) {
+ return string;
+ },
+ "@quotes/true": function (state, str) {
+ if ("undefined" === typeof str) {
+ return state.getTerm("open-quote");
+ }
+ return state.getTerm("open-quote") + str + state.getTerm("close-quote");
+ },
+ "@quotes/inner": function (state, str) {
+ if ("undefined" === typeof str) {
+ return "\u2019";
+ }
+ return state.getTerm("open-inner-quote") + str + state.getTerm("close-inner-quote");
+ },
+ "@bibliography/entry": function (state, str) {
+ return " " + str + "
\n";
+ },
+ "@display/block": function (state, str) {
+ return "\n\n " + str + "
\n";
+ },
+ "@display/left-margin": function (state, str) {
+ return "\n " + str + "
";
+ },
+ "@display/right-inline": function (state, str) {
+ return "" + str + "
\n ";
+ },
+ "@display/indent": function (state, str) {
+ return "" + str + "
\n ";
+ }
+};
+CSL.Output.Formats.prototype.text = {
+ "text_escape": function (text) {
+ return text;
+ },
+ "bibstart": "",
+ "bibend": "",
+ "@font-style/italic": false,
+ "@font-style/oblique": false,
+ "@font-style/normal": false,
+ "@font-variant/small-caps": false,
+ "@passthrough/true": CSL.Output.Formatters.passthrough,
+ "@font-variant/normal": false,
+ "@font-weight/bold": false,
+ "@font-weight/normal": false,
+ "@font-weight/light": false,
+ "@text-decoration/none": false,
+ "@text-decoration/underline": false,
+ "@vertical-align/baseline": false,
+ "@vertical-align/sup": false,
+ "@vertical-align/sub": false,
+ "@strip-periods/true": CSL.Output.Formatters.strip_periods,
+ "@strip-periods/false": function (state, string) {
+ return string;
+ },
+ "@quotes/true": function (state, str) {
+ if ("undefined" === typeof str) {
+ return state.getTerm("open-quote");
+ }
+ return state.getTerm("open-quote") + str + state.getTerm("close-quote");
+ },
+ "@quotes/inner": function (state, str) {
+ if ("undefined" === typeof str) {
+ return "\u2019";
+ }
+ return state.getTerm("open-inner-quote") + str + state.getTerm("close-inner-quote");
+ },
+ "@bibliography/entry": function (state, str) {
+ return str+"\n";
+ },
+ "@display/block": function (state, str) {
+ return "\n"+str;
+ },
+ "@display/left-margin": function (state, str) {
+ return str;
+ },
+ "@display/right-inline": function (state, str) {
+ return str;
+ },
+ "@display/indent": function (state, str) {
+ return "\n "+str;
+ }
+};
+CSL.Output.Formats.prototype.rtf = {
+ "text_escape": function (text) {
+ return text.replace("\\", "\\\\", "g").replace(/[\x7F-\uFFFF]/g,
+ function(aChar) { return "\\uc0\\u"+aChar.charCodeAt(0).toString()+" " })
+ .replace("\t", "\\tab ", "g");
+ },
+ "@font-style/italic": false,
+ "@font-style/oblique": false,
+ "@font-style/normal": false,
+ "@font-variant/small-caps": false,
+ "@passthrough/true": CSL.Output.Formatters.passthrough,
+ "@font-variant/normal": false,
+ "@font-weight/bold": false,
+ "@font-weight/normal": false,
+ "@font-weight/light": false,
+ "@text-decoration/none": false,
+ "@text-decoration/underline": false,
+ "@vertical-align/baseline": false,
+ "@vertical-align/sup": false,
+ "@vertical-align/sub": false,
+ "@strip-periods/true": CSL.Output.Formatters.strip_periods,
+ "@font-style/italic":"\\i %%STRING%%\\i0 ",
+ "@font-style/normal":false,
+ "@font-style/oblique":"\\i %%STRING%%\\i0 ",
+ "@font-variant/small-caps":"\\scaps %%STRING%%\\scaps0 ",
+ "@font-variant/normal":false,
+ "@font-weight/bold":"\\b %%STRING%%\\b0 ",
+ "@font-weight/normal":false,
+ "@font-weight/light":false,
+ "@text-decoration/none":false,
+ "@text-decoration/underline":"\\ul %%STRING%%\\ul0 ",
+ "@vertical-align/baseline":false,
+ "@vertical-align/sup":"\\super %%STRING%%\\nosupersub ",
+ "@vertical-align/sub":"\\sub %%STRING%%\\nosupersub ",
+ "@strip-periods/true": CSL.Output.Formatters.strip_periods,
+ "@strip-periods/false": function (state, string) {
+ return string;
+ },
+ "@quotes/true": function (state, str) {
+ if ("undefined" === typeof str) {
+ return CSL.Output.Formats.rtf.text_escape(state.getTerm("open-quote"));
+ }
+ return CSL.Output.Formats.rtf.text_escape(state.getTerm("open-quote")) + str + CSL.Output.Formats.rtf.text_escape(state.getTerm("close-quote"));
+ },
+ "@quotes/inner": function (state, str) {
+ if ("undefined" === typeof str) {
+ return CSL.Output.Formats.rtf.text_escape("\u2019");
+ }
+ return CSL.Output.Formats.rtf.text_escape(state.getTerm("open-inner-quote")) + str + CSL.Output.Formats.rtf.text_escape(state.getTerm("close-inner-quote"));
+ },
+ "bibstart":"{\\rtf ",
+ "bibend":"}",
+ "@display/block":"%%STRING%%\\line\r\n",
+ "@bibliography/entry": function(state,str){
+ var spacing = [];
+ for(var i=0; i -1) {
+ items = this.ambigcites[ambig].slice();
+ this.ambigcites[ambig] = items.slice(0, mypos).concat(items.slice([(mypos + 1)], items.length));
+ }
+ len = this.ambigcites[ambig].length;
+ for (pos = 0; pos < len; pos += 1) {
+ id = this.ambigcites[ambig][pos];
+ this.refreshes[id] = true;
+ }
+ delete this.registry[key];
+ }
+ }
+};
+CSL.Registry.prototype.doinserts = function (mylist) {
+ var len, pos, item, Item, akey, newitem, abase;
+ if ("string" === typeof mylist) {
+ mylist = [mylist];
+ }
+ len = mylist.length;
+ for (pos = 0; pos < len; pos += 1) {
+ item = mylist[pos];
+ if (!this.registry[item]) {
+ Item = this.state.sys.retrieveItem(item);
+ akey = CSL.getAmbiguousCite.call(this.state, Item);
+ this.akeys[akey] = true;
+ newitem = {
+ "id": item,
+ "seq": 0,
+ "offset": 0,
+ "sortkeys": false,
+ "ambig": false,
+ "disambig": false
+ };
+ this.registry[item] = newitem;
+ abase = CSL.getAmbigConfig.call(this.state);
+ this.registerAmbigToken(akey, item, abase);
+ this.touched[item] = true;
+ }
+ }
+};
+CSL.Registry.prototype.douncited = function () {
+ var pos, len;
+ for (pos = 0, len = this.mylist.length; pos < len; pos += 1) {
+ this.registry[this.mylist[pos]].uncited = false;
+ }
+ for (pos = 0, len = this.uncited.length; pos < len; pos += 1) {
+ this.registry[this.mylist[pos]].uncited = true;
+ }
+};
+CSL.Registry.prototype.rebuildlist = function () {
+ var count, len, pos, item;
+ this.reflist = [];
+ len = this.mylist.length;
+ for (pos = 0; pos < len; pos += 1) {
+ item = this.mylist[pos];
+ this.reflist.push(this.registry[item]);
+ this.registry[item].seq = (pos + 1);
+ }
+};
+CSL.Registry.prototype.dorefreshes = function () {
+ var key, regtoken, Item, old_akey, akey, abase;
+ for (key in this.refreshes) {
+ if (this.refreshes.hasOwnProperty(key)) {
+ regtoken = this.registry[key];
+ delete this.registry[key];
+ if (!regtoken) {
+ continue;
+ }
+ regtoken.disambig = undefined;
+ regtoken.sortkeys = undefined;
+ regtoken.ambig = undefined;
+ Item = this.state.sys.retrieveItem(key);
+ old_akey = akey;
+ akey = CSL.getAmbiguousCite.call(this.state, Item);
+ if (this.state.tmp.taintedItemIDs && this.state.opt.update_mode !== CSL.NUMERIC && old_akey !== akey) {
+ this.state.tmp.taintedItemIDs[key] = true;
+ }
+ this.registry[key] = regtoken;
+ abase = CSL.getAmbigConfig.call(this.state);
+ this.registerAmbigToken(akey, key, abase);
+ this.akeys[akey] = true;
+ this.touched[key] = true;
+ }
+ }
+};
+CSL.Registry.prototype.setdisambigs = function () {
+ var akey, leftovers, key, pos, len;
+ this.leftovers = [];
+ for (akey in this.akeys) {
+ if (this.akeys.hasOwnProperty(akey)) {
+ if (this.ambigcites[akey].length > 1) {
+ if (this.modes.length) {
+ leftovers = this.disambiguateCites(this.state, akey, this.modes);
+ } else {
+ leftovers = [];
+ len = this.ambigcites[akey].length;
+ for (pos = 0; pos < len; pos += 1) {
+ key = this.ambigcites[akey][pos];
+ leftovers.push(this.registry[key]);
+ }
+ }
+ if (leftovers && leftovers.length && this.state.opt.has_disambiguate) {
+ leftovers = this.disambiguateCites(this.state, akey, this.modes, leftovers);
+ }
+ if (leftovers.length > 1) {
+ this.leftovers.push(leftovers);
+ }
+ }
+ }
+ }
+ this.akeys = {};
+};
+CSL.Registry.prototype.renumber = function () {
+ var len, pos, item;
+ len = this.reflist.length;
+ for (pos = 0; pos < len; pos += 1) {
+ item = this.reflist[pos];
+ if (this.state.opt.update_mode === CSL.NUMERIC && this.state.tmp.taintedItemIDs && item.seq !== (pos + 1)) {
+ this.state.tmp.taintedItemIDs[item.id] = true;
+ }
+ item.seq = (pos + 1);
+ }
+};
+CSL.Registry.prototype.yearsuffix = function () {
+ var leftovers, pos, len, ppos, llen;
+ len = this.leftovers.length;
+ for (pos = 0; pos < len; pos += 1) {
+ leftovers = this.leftovers[pos];
+ if (leftovers && leftovers.length && this.state[this.state.tmp.area].opt["disambiguate-add-year-suffix"]) {
+ leftovers.sort(this.compareRegistryTokens);
+ llen = leftovers.length;
+ for (ppos = 0; ppos < llen; ppos += 1) {
+ this.registry[leftovers[("" + ppos)].id].disambig[2] = "" + ppos;
+ }
+ }
+ }
+};
+CSL.Registry.prototype.setsortkeys = function () {
+ var key;
+ for (key in this.touched) {
+ if (this.touched.hasOwnProperty(key)) {
+ this.registry[key].sortkeys = CSL.getSortKeys.call(this.state, this.state.sys.retrieveItem(key), "bibliography_sort");
+ }
+ }
+};
+CSL.Registry.prototype.sorttokens = function () {
+ this.reflist.sort(this.sorter.compareKeys);
+};
+CSL.Registry.Comparifier = function (state, keyset) {
+ var sort_directions, len, pos, compareKeys;
+ sort_directions = state[keyset].opt.sort_directions;
+ this.compareKeys = function (a, b) {
+ len = a.sortkeys.length;
+ for (pos = 0; pos < len; pos += 1) {
+ var cmp = 0;
+ if (a.sortkeys[pos] === b.sortkeys[pos]) {
+ cmp = 0;
+ } else if ("undefined" === typeof a.sortkeys[pos]) {
+ cmp = sort_directions[pos][1];
+ } else if ("undefined" === typeof b.sortkeys[pos]) {
+ cmp = sort_directions[pos][0];
+ } else {
+ cmp = a.sortkeys[pos].toLocaleLowerCase().localeCompare(b.sortkeys[pos].toLocaleLowerCase());
+ }
+ if (0 < cmp) {
+ return sort_directions[pos][1];
+ } else if (0 > cmp) {
+ return sort_directions[pos][0];
+ }
+ }
+ if (a.seq > b.seq) {
+ return 1;
+ } else if (a.seq < b.seq) {
+ return -1;
+ }
+ return 0;
+ };
+ compareKeys = this.compareKeys;
+ this.compareCompositeKeys = function (a, b) {
+ return compareKeys(a[1], b[1]);
+ };
+};
+CSL.Registry.prototype.compareRegistryTokens = function (a, b) {
+ if (a.seq > b.seq) {
+ return 1;
+ } else if (a.seq < b.seq) {
+ return -1;
+ }
+ return 0;
+};
+CSL.Registry.prototype.registerAmbigToken = function (akey, id, ambig_config) {
+ if (!this.ambigcites[akey]) {
+ this.ambigcites[akey] = [];
+ }
+ if (this.ambigcites[akey].indexOf(id) === -1) {
+ this.ambigcites[akey].push(id);
+ }
+ this.registry[id].ambig = akey;
+ var dome = false;
+ if (this.state.tmp.taintedItemIDs) {
+ this.registry[id].disambig = CSL.cloneAmbigConfig.call(this.state, ambig_config, this.registry[id].disambig, id);
+ } else {
+ this.registry[id].disambig = CSL.cloneAmbigConfig(ambig_config);
+ }
+};
+CSL.getSortKeys = function (Item, key_type) {
+ var area, strip_prepositions, use_parallels, len, pos;
+ area = this.tmp.area;
+ strip_prepositions = CSL.Util.Sort.strip_prepositions;
+ this.tmp.area = key_type;
+ this.tmp.disambig_override = true;
+ this.tmp.disambig_request = false;
+ use_parallels = this.parallel.use_parallels;
+ this.parallel.use_parallels = false;
+ this.tmp.suppress_decorations = true;
+ CSL.getCite.call(this, Item);
+ this.tmp.suppress_decorations = false;
+ this.parallel.use_parallels = use_parallels;
+ this.tmp.disambig_override = false;
+ len = this[key_type].keys.length;
+ for (pos = 0; pos < len; pos += 1) {
+ this[key_type].keys[pos] = strip_prepositions(this[key_type].keys[pos]);
+ }
+ this.tmp.area = area;
+ return this[key_type].keys;
+};
+CSL.Registry.NameReg = function (state) {
+ var pkey, ikey, skey, floor, ceiling, param, dagopt, gdropt, ret, pos, items, strip_periods, set_keys, evalname, delitems, addname, key;
+ this.state = state;
+ this.namereg = {};
+ this.nameind = {};
+ this.itemkeyreg = {};
+ strip_periods = function (str) {
+ if (!str) {
+ str = "";
+ }
+ return str.replace(".", " ").replace(/\s+/, " ");
+ };
+ set_keys = function (state, itemid, nameobj) {
+ pkey = strip_periods(nameobj.family);
+ skey = strip_periods(nameobj.given);
+ ikey = CSL.Util.Names.initializeWith(state, skey, "");
+ if (state[state.tmp.area].opt["givenname-disambiguation-rule"] === "by-cite") {
+ pkey = itemid + pkey;
+ }
+ };
+ evalname = function (item_id, nameobj, namenum, request_base, form, initials) {
+ var pos, len, items;
+ set_keys(this.state, item_id, nameobj);
+ if ("undefined" === typeof this.namereg[pkey] || "undefined" === typeof this.namereg[pkey].ikey[ikey]) {
+ return 2;
+ }
+ param = 2;
+ dagopt = state[state.tmp.area].opt["disambiguate-add-givenname"];
+ gdropt = state[state.tmp.area].opt["givenname-disambiguation-rule"];
+ if (gdropt === "by-cite") {
+ gdropt = "all-names";
+ }
+ if ("short" === form) {
+ param = 0;
+ } else if ("string" === typeof initials) {
+ param = 1;
+ }
+ if (param < request_base) {
+ param = request_base;
+ }
+ if (!dagopt) {
+ return param;
+ }
+ if ("string" === typeof gdropt && gdropt.slice(0, 12) === "primary-name" && namenum > 0) {
+ return param;
+ }
+ if (!gdropt || gdropt === "all-names" || gdropt === "primary-name") {
+ if (this.namereg[pkey].count > 1) {
+ param = 1;
+ }
+ if (this.namereg[pkey].ikey && this.namereg[pkey].ikey[ikey].count > 1) {
+ param = 2;
+ }
+ } else if (gdropt === "all-names-with-initials" || gdropt === "primary-name-with-initials") {
+ if (this.namereg[pkey].count > 1) {
+ param = 1;
+ }
+ }
+ if (param === 0) {
+ pos = this.namereg[pkey].ikey[ikey].items.indexOf(item_id);
+ items = this.namereg[pkey].ikey[ikey].items;
+ if (pos > -1) {
+ items = items.slice(0, pos).concat(items.slice(pos + 1));
+ }
+ for (pos = 0, len = items.length; pos < len; pos += 1) {
+ this.state.tmp.taintedItemIDs[items[pos]] = true;
+ }
+ pos = this.namereg[pkey].ikey[ikey].skey[skey].items.indexOf(item_id);
+ items = this.namereg[pkey].ikey[ikey].skey[skey].items;
+ if (pos > -1) {
+ items = items.slice(0, pos).concat(items.slice(pos + 1));
+ }
+ for (pos = 0, len = items.length; pos < len; pos += 1) {
+ this.state.tmp.taintedItemIDs[items[pos]] = true;
+ }
+ if (this.namereg[pkey].items.indexOf(item_id) === -1) {
+ this.namereg[pkey].items.push(item_id);
+ }
+ } else if (param === 1) {
+ pos = this.namereg[pkey].items.indexOf(item_id);
+ items = this.namereg[pkey].items;
+ if (pos > -1) {
+ items = items.slice(0, pos).concat(items.slice(pos + 1));
+ }
+ for (pos = 0, len = items.length; pos < len; pos += 1) {
+ this.state.tmp.taintedItemIDs[items[pos]] = true;
+ }
+ pos = this.namereg[pkey].ikey[ikey].skey[skey].items.indexOf(item_id);
+ items = this.namereg[pkey].ikey[ikey].skey[skey].items;
+ if (pos > -1) {
+ items = items.slice(0, pos).concat(items.slice(pos + 1));
+ }
+ for (pos = 0, len = items.length; pos < len; pos += 1) {
+ this.state.tmp.taintedItemIDs[items[pos]] = true;
+ }
+ if (this.namereg[pkey].ikey[ikey].items.indexOf(item_id) === -1) {
+ this.namereg[pkey].ikey[ikey].items.push(item_id);
+ }
+ } else if (param === 2) {
+ pos = this.namereg[pkey].items.indexOf(item_id);
+ items = this.namereg[pkey].items;
+ if (pos > -1) {
+ items = items.slice(0, pos).concat(items.slice(pos + 1));
+ }
+ for (pos = 0, len = items.length; pos < len; pos += 1) {
+ this.state.tmp.taintedItemIDs[items[pos]] = true;
+ }
+ pos = this.namereg[pkey].ikey[ikey].items.indexOf(item_id);
+ items = this.namereg[pkey].ikey[ikey].items;
+ if (pos > -1) {
+ items = items.slice(0, pos).concat(items.slice(pos + 1));
+ }
+ for (pos = 0, len = items.length; pos < len; pos += 1) {
+ this.state.tmp.taintedItemIDs[items[pos]] = true;
+ }
+ if (this.namereg[pkey].ikey[ikey].skey[skey].items.indexOf(item_id) === -1) {
+ this.namereg[pkey].ikey[ikey].skey[skey].items.push(item_id);
+ }
+ }
+ return param;
+ };
+ delitems = function (ids) {
+ var i, item, pos, len, posA, posB, id, fullkey, llen, ppos, otherid;
+ if ("string" === typeof ids) {
+ ids = [ids];
+ }
+ ret = {};
+ len = ids.length;
+ for (pos = 0; pos < len; pos += 1) {
+ id = ids[pos];
+ if (!this.nameind[id]) {
+ continue;
+ }
+ for (fullkey in this.nameind[id]) {
+ if (this.nameind[id].hasOwnProperty(fullkey)) {
+ key = fullkey.split("::");
+ pkey = key[0];
+ ikey = key[1];
+ skey = key[2];
+ posA = this.namereg[pkey].items.indexOf(posA);
+ items = this.namereg[pkey].items;
+ if (skey) {
+ posB = this.namereg[pkey].ikey[ikey].skey[skey].items.indexOf(id);
+ if (posB > -1) {
+ items = this.namereg[pkey].ikey[ikey].skey[skey].items.slice();
+ this.namereg[pkey].ikey[ikey].skey[skey].items = items.slice(0, posB).concat(items.slice([(posB + 1)], items.length));
+ }
+ if (this.namereg[pkey].ikey[ikey].skey[skey].items.length === 0) {
+ delete this.namereg[pkey].ikey[ikey].skey[skey];
+ this.namereg[pkey].ikey[ikey].count += -1;
+ if (this.namereg[pkey].ikey[ikey].count < 2) {
+ llen = this.namereg[pkey].ikey[ikey].items.length;
+ for (ppos = 0; ppos < llen; ppos += 1) {
+ otherid = this.namereg[pkey].ikey[ikey].items[ppos];
+ ret[otherid] = true;
+ }
+ }
+ }
+ }
+ if (ikey) {
+ posB = this.namereg[pkey].ikey[ikey].items.indexOf(id);
+ if (posB > -1) {
+ items = this.namereg[pkey].ikey[ikey].items.slice();
+ this.namereg[pkey].ikey[ikey].items = items.slice(0, posB).concat(items.slice([posB + 1], items.length));
+ }
+ if (this.namereg[pkey].ikey[ikey].items.length === 0) {
+ delete this.namereg[pkey].ikey[ikey];
+ this.namereg[pkey].count += -1;
+ if (this.namereg[pkey].count < 2) {
+ llen = this.namereg[pkey].items.length;
+ for (ppos = 0; ppos < llen; ppos += 1) {
+ otherid = this.namereg[pkey].items[ppos];
+ ret[otherid] = true;
+ }
+ }
+ }
+ }
+ if (pkey) {
+ posB = this.namereg[pkey].items.indexOf(id);
+ if (posB > -1) {
+ items = this.namereg[pkey].items.slice();
+ this.namereg[pkey].items = items.slice(0, posB).concat(items.slice([posB + 1], items.length));
+ }
+ if (this.namereg[pkey].items.length === 0) {
+ delete this.namereg[pkey];
+ }
+ }
+ delete this.nameind[id][fullkey];
+ }
+ }
+ }
+ return ret;
+ };
+ addname = function (item_id, nameobj, pos) {
+ set_keys(this.state, item_id, nameobj);
+ if (pkey) {
+ if ("undefined" === typeof this.namereg[pkey]) {
+ this.namereg[pkey] = {};
+ this.namereg[pkey].count = 0;
+ this.namereg[pkey].ikey = {};
+ this.namereg[pkey].items = [];
+ }
+ }
+ if (pkey && ikey) {
+ if ("undefined" === typeof this.namereg[pkey].ikey[ikey]) {
+ this.namereg[pkey].ikey[ikey] = {};
+ this.namereg[pkey].ikey[ikey].count = 0;
+ this.namereg[pkey].ikey[ikey].skey = {};
+ this.namereg[pkey].ikey[ikey].items = [];
+ this.namereg[pkey].count += 1;
+ }
+ }
+ if (pkey && ikey && skey) {
+ if ("undefined" === typeof this.namereg[pkey].ikey[ikey].skey[skey]) {
+ this.namereg[pkey].ikey[ikey].skey[skey] = {};
+ this.namereg[pkey].ikey[ikey].skey[skey].items = [];
+ this.namereg[pkey].ikey[ikey].count += 1;
+ }
+ }
+ if ("undefined" === typeof this.nameind[item_id]) {
+ this.nameind[item_id] = {};
+ }
+ if (pkey) {
+ this.nameind[item_id][pkey + "::" + ikey + "::" + skey] = true;
+ }
+ };
+ this.addname = addname;
+ this.delitems = delitems;
+ this.evalname = evalname;
+};
+var debug = false;
+CSL.Registry.prototype.disambiguateCites = function (state, akey, modes, candidate_list) {
+ var ambigs, reg_token, keypos, id_vals, a, base, token, pos, len, tokens, str, maxvals, minval, testpartner, otherstr, base_return, ret, id, key;
+ if (!candidate_list) {
+ ambigs = this.ambigcites[akey].slice();
+ this.ambigcites[akey] = [];
+ } else {
+ ambigs = [];
+ len = candidate_list.length;
+ for (pos = 0; pos < len; pos += 1) {
+ reg_token = candidate_list[pos];
+ ambigs.push(reg_token.id);
+ keypos = this.ambigcites[akey].indexOf(reg_token.id);
+ if (keypos > -1) {
+ this.ambigcites[akey] = this.ambigcites[akey].slice(0, keypos).concat(this.ambigcites[akey].slice((keypos + 1)));
+ }
+ }
+ }
+ id_vals = [];
+ len = ambigs.length;
+ for (pos = 0; pos < len; pos += 1) {
+ id_vals.push(ambigs[pos]);
+ }
+ tokens = state.retrieveItems(id_vals);
+ if (candidate_list && candidate_list.length) {
+ modes = ["disambiguate_true"].concat(modes);
+ }
+ CSL.initCheckerator.call(this.checkerator, tokens, modes);
+ this.checkerator.lastclashes = (ambigs.length - 1);
+ base = false;
+ this.checkerator.pos = 0;
+ str = CSL.getAmbiguousCite.call(state, tokens[0], base);
+ maxvals = CSL.getMaxVals.call(state);
+ minval = CSL.getMinVal.call(state);
+ base = CSL.getAmbigConfig.call(state);
+ while (CSL.runCheckerator.call(this.checkerator)) {
+ token = this.checkerator.tokens[this.checkerator.pos];
+ if (this.ambigcites[akey].indexOf(token.id) > -1) {
+ this.checkerator.pos += 1;
+ continue;
+ }
+ this.checkerator.candidate = token.id;
+ if (base === false) {
+ this.checkerator.mode = modes[0];
+ }
+ str = CSL.getAmbiguousCite.call(state, token, base);
+ maxvals = CSL.getMaxVals.call(state);
+ minval = CSL.getMinVal.call(state);
+ base = CSL.getAmbigConfig.call(state);
+ if (candidate_list && candidate_list.length) {
+ base.disambiguate = true;
+ }
+ CSL.setCheckeratorBase.call(this.checkerator, base);
+ CSL.setMaxVals.call(this.checkerator, maxvals);
+ CSL.setMinVal.call(this.checkerator, minval);
+ len = tokens.length;
+ for (pos = 0; pos < len; pos += 1) {
+ testpartner = tokens[pos];
+ if (token.id === testpartner.id) {
+ continue;
+ }
+ otherstr = CSL.getAmbiguousCite.call(state, testpartner, base);
+ if (CSL.checkCheckeratorForClash.call(this.checkerator, str, otherstr)) {
+ break;
+ }
+ }
+ if (CSL.evaluateCheckeratorClashes.call(this.checkerator)) {
+ base_return = CSL.decrementCheckeratorNames.call(this, state, base);
+ this.registerAmbigToken(akey, token.id, base_return);
+ this.checkerator.seen.push(token.id);
+ continue;
+ }
+ if (CSL.maxCheckeratorAmbigLevel.call(this.checkerator)) {
+ if (!state.citation.opt["disambiguate-add-year-suffix"]) {
+ this.checkerator.mode1_counts = false;
+ this.checkerator.maxed_out_bases[token.id] = CSL.cloneAmbigConfig(base);
+ } else {
+ }
+ this.checkerator.seen.push(token.id);
+ base = false;
+ continue;
+ }
+ CSL.incrementCheckeratorAmbigLevel.call(this.checkerator);
+ }
+ ret = [];
+ len = this.checkerator.ids.length;
+ for (pos = 0; pos < len; pos += 1) {
+ id = this.checkerator.ids[pos];
+ if (id) {
+ ret.push(this.registry[id]);
+ }
+ }
+ len = this.checkerator.maxed_out_bases.length;
+ for (key in this.checkerator.maxed_out_bases) {
+ if (this.checkerator.maxed_out_bases.hasOwnProperty(key)) {
+ this.registry[key].disambig = this.checkerator.maxed_out_bases[key];
+ }
+ }
+ return ret;
+};
+CSL.Checkerator = function () {};
+CSL.initCheckerator = function (tokens, modes) {
+ var len, pos;
+ this.tokens = tokens;
+ this.seen = [];
+ this.modes = modes;
+ this.mode = this.modes[0];
+ this.tokens_length = tokens.length;
+ this.pos = 0;
+ this.clashes = 0;
+ this.maxvals = false;
+ this.base = false;
+ this.ids = [];
+ this.maxed_out_bases = {};
+ len = tokens.length;
+ for (pos = 0; pos < len; pos += 1) {
+ this.ids.push(tokens[pos].id);
+ }
+ this.lastclashes = -1;
+ this.namepos = 0;
+ this.modepos = 0;
+ this.mode1_counts = false;
+};
+CSL.runCheckerator = function () {
+ var len, pos;
+ if (this.seen.length < this.tokens_length) {
+ return true;
+ }
+ return false;
+};
+CSL.setMaxVals = function (maxvals) {
+ this.maxvals = maxvals;
+};
+CSL.setMinVal = function (minval) {
+ this.minval = minval;
+};
+CSL.setCheckeratorBase = function (base) {
+ var pos, len;
+ this.base = base;
+ if (! this.mode1_counts) {
+ this.mode1_counts = [];
+ len = this.base.givens.length;
+ for (pos = 0; pos < len; pos += 1) {
+ this.mode1_counts.push(0);
+ }
+ }
+};
+CSL.setCheckeratorMode = function (mode) {
+ this.mode = mode;
+};
+CSL.checkCheckeratorForClash = function (str, otherstr) {
+ if (str === otherstr) {
+ if (this.mode === "names" || this.mode === "disambiguate_true") {
+ this.clashes += 1;
+ return true;
+ }
+ if (this.mode === "givens") {
+ this.clashes += 1;
+ }
+ return false;
+ }
+};
+CSL.evaluateCheckeratorClashes = function () {
+ var namepos, ret, old;
+ if (!this.maxvals.length) {
+ return false;
+ }
+ if (this.mode === "names" || this.mode === "disambiguate_true") {
+ if (this.clashes) {
+ this.lastclashes = this.clashes;
+ this.clashes = 0;
+ return false;
+ } else {
+ this.ids[this.pos] = false;
+ this.pos += 1;
+ this.lastclashes = this.clashes;
+ return true;
+ }
+ }
+ if (this.mode === "givens") {
+ ret = true;
+ namepos = this.mode1_counts[this.modepos];
+ if (this.clashes && this.clashes === this.lastclashes) {
+ if (this.mode1_defaults && namepos > 0) {
+ old = this.mode1_defaults[(namepos - 1)];
+ this.base.givens[this.modepos][(namepos - 1)] = old;
+ }
+ ret = false;
+ } else if (this.clashes) {
+ ret = false;
+ } else { // only non-clash should be possible
+ this.mode1_counts = false;
+ this.pos += 1;
+ ret = true;
+ }
+ this.lastclashes = this.clashes;
+ this.clashes = 0;
+ if (ret) {
+ this.ids[this.pos] = false;
+ }
+ return ret;
+ }
+};
+CSL.maxCheckeratorAmbigLevel = function () {
+ if (!this.maxvals.length) {
+ return true;
+ }
+ if (this.mode === "disambiguate_true") {
+ if (this.modes.indexOf("disambiguate_true") < (this.modes.length - 1)) {
+ this.mode = this.modes[(this.modes.indexOf("disambiguate_true") + 1)];
+ this.modepos = 0;
+ } else {
+ this.pos += 1;
+ return true;
+ }
+ }
+ if (this.mode === "names") {
+ if (this.modepos === (this.base.names.length - 1) && this.base.names[this.modepos] === this.maxvals[this.modepos]) {
+ if (this.modes.length === 2) {
+ this.mode = "givens";
+ this.mode1_counts[this.modepos] = 0;
+ this.modepos = 0;
+ } else {
+ this.pos += 1;
+ return true;
+ }
+ }
+ } else if (this.mode === "givens") {
+ if (this.modepos === (this.mode1_counts.length - 1) && this.mode1_counts[this.modepos] === (this.maxvals[this.modepos])) {
+ if (this.modes.length === 2) {
+ this.mode = "givens";
+ this.pos += 1;
+ } else {
+ this.pos += 1;
+ }
+ return true;
+ }
+ }
+ return false;
+};
+CSL.incrementCheckeratorAmbigLevel = function () {
+ var val;
+ if (this.mode === "names") {
+ val = this.base.names[this.modepos];
+ if (val < this.maxvals[this.modepos]) {
+ this.base.names[this.modepos] += 1;
+ } else if (this.modepos < (this.base.names.length - 1)) {
+ this.modepos += 1;
+ this.base.names[this.modepos] = 0;
+ }
+ }
+ if (this.mode === "givens") {
+ val = (this.mode1_counts[this.modepos]);
+ if (val < this.maxvals[this.modepos]) {
+ if (this.given_name_second_pass) {
+ this.given_name_second_pass = false;
+ this.mode1_counts[this.modepos] += 1;
+ this.base.givens[this.modepos][val] += 1;
+ } else {
+ this.mode1_defaults = this.base.givens[this.modepos].slice();
+ this.given_name_second_pass = true;
+ }
+ } else if (this.modepos < (this.base.givens.length - 1)) {
+ this.modepos += 1;
+ this.base.givens[this.modepos][0] += 1;
+ this.mode1_defaults = this.base.givens[this.modepos].slice();
+ } else {
+ this.mode = "names";
+ this.pos += 1;
+ }
+ }
+};
+CSL.decrementCheckeratorNames = function (state, base) {
+ var base_return, do_me, i, j, pos, len, ppos, llen;
+ base_return = CSL.cloneAmbigConfig(base);
+ do_me = false;
+ len = base_return.givens.length - 1;
+ for (pos = len; pos > -1; pos += -1) {
+ llen = base_return.givens[pos].length - 1;
+ for (ppos = llen; ppos > -1; ppos += -1) {
+ if (base_return.givens[pos][ppos] === 2) {
+ do_me = true;
+ }
+ }
+ }
+ if (do_me) {
+ len = base_return.givens.length - 1;
+ for (pos = len; pos > -1; pos += -1) {
+ llen = base_return.givens[pos].length - 1;
+ for (ppos = llen; ppos > -1; ppos += -1) {
+ if (base_return.givens[pos][ppos] === 2) {
+ i = -1;
+ break;
+ }
+ if (ppos < base_return.names[pos]) {
+ base_return.names[pos] += -1;
+ }
+ }
+ }
+ }
+ return base_return;
+};
+CSL.getAmbigConfig = function () {
+ var config, ret;
+ config = this.tmp.disambig_request;
+ if (!config) {
+ config = this.tmp.disambig_settings;
+ }
+ ret = CSL.cloneAmbigConfig(config);
+ return ret;
+};
+CSL.getMaxVals = function () {
+ return this.tmp.names_max.mystack.slice();
+};
+CSL.getMinVal = function () {
+ return this.tmp["et-al-min"];
+};
+CSL.getModes = function () {
+ var ret, dagopt, gdropt;
+ ret = [];
+ if (this[this.tmp.area].opt["disambiguate-add-names"]) {
+ ret.push("names");
+ }
+ dagopt = this[this.tmp.area].opt["disambiguate-add-givenname"];
+ gdropt = this[this.tmp.area].opt["givenname-disambiguation-rule"];
+ if (dagopt) {
+ if (!gdropt || ("string" === typeof gdropt && "primary-name" !== gdropt.slice(0, 12))) {
+ ret.push("givens");
+ }
+ }
+ return ret;
+};
+CSL.Registry.CitationReg = function (state) {
+ this.citationById = {};
+ this.citationByIndex = [];
+};
diff --git a/chrome/content/zotero/xpcom/csl.js b/chrome/content/zotero/xpcom/csl.js
deleted file mode 100644
index 0df5b7d223..0000000000
--- a/chrome/content/zotero/xpcom/csl.js
+++ /dev/null
@@ -1,2956 +0,0 @@
-/*
- ***** BEGIN LICENSE BLOCK *****
-
- Copyright © 2009 Center for History and New Media
- George Mason University, Fairfax, Virginia, USA
- http://zotero.org
-
- This file is part of Zotero.
-
- Zotero is free software: you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation, either version 3 of the License, or
- (at your option) any later version.
-
- Zotero is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with Zotero. If not, see .
-
- ***** END LICENSE BLOCK *****
-*/
-
-/*
- * CSL: a class for creating bibliographies from CSL files
- * this is abstracted as a separate class for the benefit of anyone who doesn't
- * want to use the Scholar data model, but does want to use CSL in JavaScript
- */
-Zotero.CSL = function(csl) {
- // "with ({});" needed to fix default namespace scope issue
- // See https://bugzilla.mozilla.org/show_bug.cgi?id=330572
- default xml namespace = "http://purl.org/net/xbiblio/csl"; with ({});
-
- if(typeof csl != "xml") {
- this._csl = new XML(Zotero.CSL.Global.cleanXML(csl));
- } else {
- this._csl = csl;
- }
-
- // initialize CSL
- Zotero.CSL.Global.init();
-
- // load localizations
- this._terms = Zotero.CSL.Global.parseLocales(this._csl.terms);
-
- // load class and styleID
- this.styleID = this._csl.info.id.toString();
- this.class = this._csl["@class"].toString();
- Zotero.debug("CSL: style class is "+this.class);
-
- this.hasBibliography = (this._csl.bibliography.length() ? 1 : 0);
-}
-
-/*
- * Constants for citation positions
- */
-Zotero.CSL.POSITION_FIRST = 0;
-Zotero.CSL.POSITION_SUBSEQUENT = 1;
-Zotero.CSL.POSITION_IBID = 2;
-Zotero.CSL.POSITION_IBID_WITH_LOCATOR = 3;
-
-
-Zotero.CSL._dateVariables = {
- "issued":true,
- "accessed":true,
- "submitted":true
-}
-
-Zotero.CSL._namesVariables = {
- "editor":true,
- "translator":true,
- "recipient":true,
- "interviewer":true,
- "collection-editor":true,
- "container-author":true,
- "author":true
-}
-
-/*
- * Constants for name (used for disambiguate-add-givenname)
- */
-Zotero.CSL.NAME_USE_INITIAL = 1;
-Zotero.CSL.NAME_USE_FULL = 2;
-
-/*
- * generate an item set
- */
-Zotero.CSL.prototype.createItemSet = function(items) {
- return new Zotero.CSL.ItemSet(items, this);
-}
-
-/*
- * generate a citation object
- */
-Zotero.CSL.prototype.createCitation = function(citationItems) {
- return new Zotero.CSL.Citation(citationItems, this);
-}
-
-/*
- * create a citation (in-text or footnote)
- */
-Zotero.CSL._firstNameRegexp = /^[^\s]*/;
-Zotero.CSL._textCharRegexp = /[a-zA-Z0-9]/;
-Zotero.CSL._numberRegexp = /\d+/;
-Zotero.CSL._quotedRegexp = /^".+"$/;
-Zotero.CSL.prototype.formatCitation = function(citation, format) {
- default xml namespace = "http://purl.org/net/xbiblio/csl"; with({});
-
- var context = this._csl.citation;
- if(!context) {
- throw "CSL: formatCitation called on style with no citation context";
- }
- if(!citation.citationItems.length) {
- throw "CSL: formatCitation called with empty citation";
- }
-
- // clone citationItems, so as not to disturb the citation
- var citationItems = citation.citationItems;
-
- // handle collapse
- var cslAdded = [];
-
- var collapse = context.option.(@name == "collapse").@value.toString();
- if(collapse) {
- // clone citationItems, so as not to disturb the citation
- citationItems = new Array();
-
- if(collapse == "citation-number") {
- // loop through, collecting citation numbers
- var citationNumbers = new Object();
- for(var i=0; i 2) {
- // if previous set of citations was a range, collapse them
- var firstNumber = citationItems[span[0]].item.getProperty("citation-number");
- citationItems[span[0]]._csl = {"citation-number":(firstNumber+"-"+(parseInt(firstNumber, 10)+span.length-1))};
- cslAdded.push(span[0]);
- } else if(span.length == 2) {
- citationItems[span[1]] = citation.citationItems[span[1]];
- }
-
- span = [citationNumbers[i]];
- }
- previousI = i;
- }
- } else if(collapse.substr(0, 4) == "year") {
- // loop through, collecting citations (sans date) in an array
- var lastNames = {};
- for(var i=0; i 1) {
- for(k=1; k\r\n';
- } else {
- preamble += '\r\n';
- }
- }
- } else {
- if(format == "RTF" || format == "Integration") {
- if(format == "RTF") {
- preamble = "{\\rtf\\ansi{\\fonttbl\\f0\\froman Times New Roman;}{\\colortbl;\\red255\\green255\\blue255;}\\pard\\f0\r\n";
- }
-
- var tabStop = null;
- if(hangingIndent) {
- var indent = 720; // 720 twips = 0.5 in
- var firstLineIndent = -720; // -720 twips = -0.5 in
- } else {
- var indent = 0;
- var firstLineIndent = 0;
- }
- }
-
- var returnChars = "";
- for(j=0; j<=entrySpacing; j++) {
- if(format == "RTF") {
- returnChars += "\\\r\n";
- } else if(Zotero.isWin) {
- returnChars += "\r\n";
- } else {
- returnChars += "\n";
- }
- }
- }
-
- var maxFirstFieldLength = 0;
- for(var i in itemSet.items) {
- var item = itemSet.items[i];
- if(item == undefined) continue;
-
- // try to get custom bibliography
- var string = item.getProperty("bibliography-"+(format == "Integration" ? "RTF" : format));
- if(!string) {
- string = new Zotero.CSL.FormattedString(context, format);
- this._processElements(item, context.layout, string, context);
- if(!string) {
- continue;
- }
-
- // add format
- string.string = context.layout.@prefix.toString() + string.string;
- if(context.layout.@suffix.length()) {
- string.append(context.layout.@suffix.toString());
- }
-
- string = string.get();
- }
-
- if(secondFieldAlign && (format == "RTF" || format == "Integration")) {
- if(format == "RTF") {
- var tab = string.indexOf("\\tab ");
- } else {
- var tab = string.indexOf("\t");
- }
- if(tab > maxFirstFieldLength) {
- maxFirstFieldLength = tab;
- }
- }
-
- // add line feeds
- if(format == "HTML") {
- var coins = Zotero.OpenURL.createContextObject(item.zoteroItem, "1.0");
-
- // Wrap URLs and DOIs in HTML links
- //
- // This should be handled when the values are still in variables
- // (and presumably will be in the new engine)
- string = Zotero.Utilities.prototype.autoLink(string);
-
- var span = (coins ? ' ' : '');
-
- if(this.class == "note" && isCitation) {
- output += "
"+string+span+"\r\n";
- } else if(secondFieldAlign) {
- output += '| '+string+span+" |
\r\n";
- for(var j=0; j'+string+span+"\r\n";
- }
- } else {
- if(this.class == "note" && isCitation) {
- if(format == "RTF") {
- index++;
- output += index+". ";
- } else if(format == "Text") {
- index++;
- output += index+". ";
- }
- }
- output += string+returnChars;
- }
- }
-
- if(format == "HTML") {
- if(this.class == "note" && isCitation) {
- output += '';
- } else if(secondFieldAlign) {
- output += '';
- } else {
- output += '';
- }
- } else if(format == "RTF" || format == "Integration") {
- if(secondFieldAlign) {
- // this is a really sticky issue. the below works for first fields
- // that look like "[1]" and "1." otherwise, i have no idea. luckily,
- // this will be good enough 99% of the time.
- var alignAt = 24+maxFirstFieldLength*120;
-
- if(secondFieldAlign == "margin") {
- firstLineIndent -= alignAt;
- tabStop = 0;
- } else {
- indent += alignAt;
- firstLineIndent = -indent;
- tabStop = indent;
- }
- }
-
- preamble += "\\li"+indent+" \\fi"+firstLineIndent+" ";
- if(format == "Integration") {
- preamble += "\\sl"+lineSpacing+" ";
- } else if(format == "RTF" && lineSpacing != 1) {
- preamble += "\\sl"+(240*lineSpacing)+" \\slmult1 ";
- }
-
- if(tabStop !== null) {
- preamble += "\\tx"+tabStop+" ";
- }
- preamble += "\r\n";
-
- // drop last returns
- output = output.substr(0, output.length-returnChars.length);
-
- // add bracket for RTF
- if(format == "RTF") output += "\\par }";
- }
-
- return preamble+output;
-}
-
-/*
- * gets a term, in singular or plural form
- */
-Zotero.CSL.prototype._getTerm = function(term, plural, form, includePeriod) {
- if(!form) {
- form = "long";
- }
-
- if(!this._terms[form] || !this._terms[form][term]) {
- if(form == "verb-short") {
- return this._getTerm(term, plural, "verb");
- } else if(form == "symbol") {
- return this._getTerm(term, plural, "short");
- } else if(form != "long") {
- return this._getTerm(term, plural, "long");
- } else {
- Zotero.debug("CSL: WARNING: could not find term \""+term+'"');
- return "";
- }
- }
-
- var term;
- if(typeof(this._terms[form][term]) == "object") { // singular and plural forms
- // are available
- if(plural) {
- term = this._terms[form][term][1];
- } else {
- term = this._terms[form][term][0];
- }
- } else {
- term = this._terms[form][term];
- }
-
- if((form == "short" || form == "verb-short") && includePeriod) {
- term += ".";
- }
-
- return term;
-}
-
-/*
- * process creator objects; if someone had a creator model that handled
- * non-Western names better than ours, this would be the function to change
- */
-Zotero.CSL.prototype._processNames = function(item, element, formattedString, context, citationItem, variables) {
- default xml namespace = "http://purl.org/net/xbiblio/csl"; with({});
-
- var children = element.children();
- if(!children.length()) return false;
- var variableSucceeded = false;
-
- for(var j=0; j= Zotero.CSL.POSITION_SUBSEQUENT) {
- if(context.option.(@name == "et-al-subsequent-min").length()) {
- etAlMin = context.option.(@name == "et-al-subsequent-min").@value.toString();
- }
- if(context.option.(@name == "et-al-subsequent-use-first").length()) {
- etAlUseFirst = context.option.(@name == "et-al-subsequent-use-first").@value.toString();
- }
- }
-
- if(etAlMin && etAlUseFirst && maxCreators >= parseInt(etAlMin, 10)) {
- etAlUseFirst = parseInt(etAlUseFirst, 10);
- if(etAlUseFirst != maxCreators) {
- maxCreators = etAlUseFirst;
- useEtAl = true;
- }
- }
-
- // add additional names to disambiguate
- if(variables[j] == "author" && useEtAl) {
- var disambigNames = item.getProperty("disambiguate-add-names");
- if(disambigNames != "") {
- maxCreators = disambigNames;
- if(disambigNames == creators.length) useEtAl = false;
- }
- }
-
- if(child.@form == "short") {
- var fullNames = item.getProperty("disambiguate-add-givenname").split(",");
- }
- }
-
- var authorStrings = [];
- var firstName, lastName;
- // parse authors into strings
- for(var i=0; i 1 && lastNameParts[0] !== "" && lastNameParts[0].length <= 4
- && lastNameParts[0][0].toLowerCase() == lastNameParts[0][0]
- && lastNameParts[lastNameParts.length-1][0].toUpperCase() == lastNameParts[lastNameParts.length-1][0]) {
- name = "";
- for(var k=1; k 1) {
- if(useEtAl) { // multiple creators and need et al
- authorStrings.push(this._getTerm("et-al"));
- } else { // multiple creators but no et al
- // add and to last creator
- if(child["@and"].length()) {
- if(child["@and"] == "symbol") {
- var and = "&"
- } else if(child["@and"] == "text") {
- var and = this._getTerm("and");
- }
-
- authorStrings[maxCreators-1] = and+" "+authorStrings[maxCreators-1];
- }
- }
-
- // check whether to use a serial comma
- if((authorStrings.length == 2 && (child["@delimiter-precedes-last"] != "always" || useEtAl)) ||
- (authorStrings.length > 2 && child["@delimiter-precedes-last"] == "never")) {
- var lastString = authorStrings.pop();
- authorStrings[authorStrings.length-1] = authorStrings[authorStrings.length-1]+" "+lastString;
- }
- }
- newString.append(authorStrings.join(joinString), child);
- }
- } else if(formattedString.format != "Sort" &&
- name == "label" && variables[j] != "author") {
- newString.append(this._getTerm(variables[j], (maxCreators != 1 || useEtAl), child["@form"].toString(), child["@include-period"] == "true"), child);
- }
- }
- success = true;
- }
- }
-
- if(success) {
- variableSucceeded = true;
- formattedString.concat(newString);
- }
- }
-
- return variableSucceeded;
-}
-
-/*
- * processes an element from a (pre-processed) item into text
- */
-Zotero.CSL.prototype._processElements = function(item, element, formattedString,
- context, citationItem, ignore, isSingle) {
- default xml namespace = "http://purl.org/net/xbiblio/csl"; with({});
-
- if(!ignore) {
- ignore = [[], []];
- // ignore[0] is for variables; ignore[1] is for macros
- }
-
- var dataAppended = false;
-
- if(isSingle) {
- // handle single elements
- var numberOfChildren = 1;
- var children = [element];
- } else {
- // accept groups of elements by default
- var children = element.children();
- var numberOfChildren = children.length();
- var lastChild = children.length()-1;
- }
-
- for(var i=0; i 0
- }
- else if(Zotero.CSL._dateVariables[variables[j]]) {
- // getDate not false/undefined
- exists = !!item.getDate(variables[j]);
- } else if(Zotero.CSL._namesVariables[variables[j]]) {
- // getNames not false/undefined, not empty
- exists = item.getNames(variables[j]);
- if(exists) exists = !!exists.length;
- } else {
- exists = item.getVariable(variables[j]);
- if (exists) exists = !!exists.length;
- }
- } else if (attribute == "is-numeric") {
- exists = item.getNumericVariable(variables[j]);
- } else if (attribute == "is-date") { // XXX - this needs improving
- if (Zotero.CSL._dateVariables[variables[j]]) {
- exists = !!item.getDate(variables[j]);
- }
- } else if(attribute == "is-plural") {
- if(Zotero.CSL._namesVariables[variables[j]]) {
- exists = item.getNames(variables[j]);
- if(exists) exists = exists.length > 1;
- } else if(variables[j] == "page" || variables[j] == "locator") {
- if(variables[j] == "page") {
- var value = item.getVariable("page");
- } else {
- var value = citationItem && citationItem.locator ? citationItem.locator : "";
- }
- exists = value.indexOf("-") != -1 || value.indexOf(",") != -1 || value.indexOf("\u2013") != -1;
- }
- } else if(attribute == "type") {
- exists = item.isType(variables[j]);
- } else if(attribute == "disambiguate") {
- exists = (variables[j] == "true" && item.getProperty("disambiguate-condition"))
- || (variables[j] == "false" && !item.getProperty("disambiguate-condition"));
- } else if(attribute == "locator") {
- exists = citationItem && citationItem.locator &&
- (citationItem.locatorType == variables[j]
- || (!citationItem.locatorType && variables[j] == "page"));
- } else { // attribute == "position"
- if(variables[j] == "first") {
- exists = !citationItem
- || !citationItem.position
- || citationItem.position == Zotero.CSL.POSITION_FIRST;
- } else if(variables[j] == "subsequent") {
- exists = citationItem && citationItem.position >= Zotero.CSL.POSITION_SUBSEQUENT;
- } else if(variables[j] == "ibid") {
- exists = citationItem && citationItem.position >= Zotero.CSL.POSITION_IBID;
- } else if(variables[j] == "ibid-with-locator") {
- exists = citationItem && citationItem.position == Zotero.CSL.POSITION_IBID_WITH_LOCATOR;
- }
- }
-
- if(matchAny) {
- if(exists) {
- truthValue = true;
- done = true;
- }
- } else if(matchNone) {
- if(exists) {
- truthValue = false;
- done = true;
- }
- } else if(!exists) {
- truthValue = false;
- done = true;
- }
- }
- }
- }
- }
-
- if(truthValue) {
- // if true, process
- var newString = formattedString.clone(newChild.@delimiter.toString());
- var success = this._processElements(item, newChild,
- newString, context, citationItem, ignore);
- if(success) dataAppended = true;
- formattedString.concat(newString, child);
-
- // then break
- break;
- }
- }
- } else {
- Zotero.debug("CSL: WARNING: could not add element "+name);
- }
- }
-
- return dataAppended;
-}
-
-/*
- * Compares two items, in order to sort the reference list
- * Returns -1 if A comes before B, 1 if B comes before A, or 0 if they are equal
- */
-Zotero.CSL.prototype._compareItem = function(a, b, context, cache) {
- default xml namespace = "http://purl.org/net/xbiblio/csl"; with({});
-
- var sortA = [];
- var sortB = [];
-
- var aID = a.id;
- var bID = b.id;
-
- // author
- if(context.sort.key.length()) {
- var keyA, keyB;
- for each(var key in context.sort.key) {
- if(key.@macro.length()) {
- var aCacheKey = aID+"-macro-"+key.@macro;
- var bCacheKey = bID+"-macro-"+key.@macro;
-
- if(cache[aCacheKey]) {
- keyA = cache[aCacheKey];
- } else {
- keyA = new Zotero.CSL.SortString();
- this._processElements(a, this._csl.macro.(@name == key.@macro), keyA);
- cache[aCacheKey] = keyA;
- }
-
- if(cache[bCacheKey]) {
- keyB = cache[bCacheKey];
- } else {
- keyB = new Zotero.CSL.SortString();
- this._processElements(b, this._csl.macro.(@name == key.@macro), keyB);
- cache[bCacheKey] = keyB;
- }
- } else if(key.@variable.length()) {
- var variable = key.@variable.toString();
- var keyA = new Zotero.CSL.SortString();
- var keyB = new Zotero.CSL.SortString();
-
- if(Zotero.CSL._dateVariables[variable]) { // date
- var date = a.getDate(variable);
- if(date) keyA.append(date.getDateVariable("sort"));
- date = b.getDate(variable);
- if(date) keyB.append(date.getDateVariable("sort"));
- } else if(Zotero.CSL._namesVariables[key.@variable]) { // names
- var element = ;
- element.setNamespace(Zotero.CSL.Global.ns);
-
- this._processNames(a, element, keyA, context, null, [variable]);
- this._processNames(b, element, keyB, context, null, [variable]);
- } else { // text
- if(variable == "citation-number") {
- keyA.append(a.getProperty(variable));
- keyB.append(b.getProperty(variable));
- } else {
- keyA.append(a.getVariable(variable));
- keyB.append(b.getVariable(variable));
- }
- }
- }
-
- var compare = keyA.compare(keyB);
- if(key.@sort == "descending") { // the compare method sorts ascending
- // so we sort descending by reversing it
- if(compare < 1) return 1;
- if(compare > 1) return -1;
- } else if(compare != 0) {
- return compare;
- }
- }
- }
-
- // sort by index in document
- var aIndex = a.getProperty("index");
- var bIndex = b.getProperty("index");
- if(aIndex !== "" && (bIndex === "" || aIndex < bIndex)) {
- return -1;
- } else if(aIndex != bIndex) {
- return 1;
- }
-
- // sort by old index (to make this a stable sort)
- var aOldIndex = a.getProperty("oldIndex");
- var bOldIndex = b.getProperty("oldIndex");
- if(aOldIndex < bOldIndex) {
- return -1;
- } else if(aOldIndex != bOldIndex) {
- return 1;
- }
-
- return 0;
-}
-
-
-/**
- * Sorts a list of items, keeping a cache of processed keys
- **/
-Zotero.CSL.prototype.cachedSort = function(items, context, field) {
- var me = this;
- var cache = new Object();
-
- for(var i=0; i]*\?>/g, "");
- }
-
- /*
- * parses locale strings into an array;
- */
- function parseLocales(termXML, ignoreLang) {
- // return defaults if there are no terms
- if(!termXML.length()) {
- return (Zotero.CSL.Global._defaultTerms ? Zotero.CSL.Global._defaultTerms : {});
- }
-
- var xml = new Namespace("http://www.w3.org/XML/1998/namespace");
-
- if(ignoreLang) {
- // ignore lang if loaded from chrome
- locale = termXML.locale[0];
- } else {
- // get proper locale
- var locale = termXML.locale.(@xml::lang == Zotero.CSL.Global._xmlLang);
- if(!locale.length()) {
- var xmlLang = Zotero.CSL.Global._xmlLang.substr(0, 2);
- locale = termXML.locale.(@xml::lang == xmlLang);
- }
- if(!locale.length()) {
- // return defaults if there are no locales
- return (Zotero.CSL.Global._defaultTerms ? Zotero.CSL.Global._defaultTerms : {});
- }
- }
-
- var termArray = new Object();
- termArray["default"] = new Object();
-
- if(Zotero.CSL.Global._defaultTerms) {
- // ugh. copy default array. javascript dumb.
- for(var i in Zotero.CSL.Global._defaultTerms) {
- termArray[i] = new Object();
- for(var j in Zotero.CSL.Global._defaultTerms[i]) {
- if(typeof(Zotero.CSL.Global._defaultTerms[i][j]) == "object") {
- termArray[i][j] = Zotero.CSL.Global._defaultTerms[i][j].concat();
- } else {
- termArray[i][j] = Zotero.CSL.Global._defaultTerms[i][j];
- }
- }
- }
- }
-
- // loop through terms
- for each(var term in locale.term) {
- var name = term.@name.toString();
- if(!name) {
- throw("CSL: citations cannot be generated: no name defined on term in locales.xml");
- }
- // unless otherwise specified, assume "long" form
- var form = term.@form.toString();
- if(!form) {
- var form = "long";
- }
- if(!termArray[form]) {
- termArray[form] = new Object();
- }
-
- var single = term.single.text().toString();
- var multiple = term.multiple.text().toString();
- if(single || multiple) {
- if((single && multiple) // if there's both elements or
- || !termArray[form][name]) { // no previously defined value
- termArray[form][name] = [single, multiple];
- } else {
- if(typeof(termArray[name]) != "object") {
- // if old object was just a single value, make it two copies
- termArray[form][name] = [termArray[form][name], termArray[form][name]];
- }
-
- // redefine either single or multiple
- if(single) {
- termArray[form][name][0] = single;
- } else {
- termArray[form][name][1] = multiple;
- }
- }
- } else {
- if(name.substr(0, 6) == "month-") {
- // place months into separate array
- if(!termArray[form]["_months"]) {
- termArray[form]["_months"] = new Array();
- }
- var monthIndex = parseInt(name.substr(6),10)-1;
- var term = term.text().toString();
- termArray[form]["_months"][monthIndex] = term[0].toUpperCase()+term.substr(1).toLowerCase();
- } else {
- termArray[form][name] = term.text().toString();
- }
- }
- }
-
- // ensure parity between long and short months
- var longMonths = termArray["long"]["_months"];
- var shortMonths = termArray["short"]["_months"];
- for(var i=0; i 5000) return "";
- var thousands = parseInt(number/1000);
- if (thousands > 0) {
- result += Zotero.CSL.Item._zoteroRomanNumerals[3][thousands];
- }
- number = number % 1000;
- var hundreds = parseInt(number/100);
- if (hundreds > 0) {
- result += Zotero.CSL.Item._zoteroRomanNumerals[2][hundreds];
- }
- number = number % 100;
- var tens = parseInt(number/10);
- if (tens > 0) {
- result += Zotero.CSL.Item._zoteroRomanNumerals[1][tens];
- }
- number = number % 10;
- if (number > 0) {
- result += Zotero.CSL.Item._zoteroRomanNumerals[0][number];
- }
- return result;
-}
-
-Zotero.CSL.Item._zoteroNumberFieldMap = {
- "volume":"volume",
- "issue":"issue",
- "number-of-volumes":"numberOfVolumes",
- "edition":"edition",
- "number":"number"
-}
-/*
- * Gets a numeric object for a specific type.
- */
-Zotero.CSL.Item.prototype.getNumericVariable = function(variable, form) {
-
- if(!Zotero.CSL.Item._zoteroNumberFieldMap[variable]) return "";
-
- var zoteroFields = [];
- var field;
-
- field = Zotero.CSL.Item._zoteroNumberFieldMap[variable];
- if(typeof field == "string") {
- zoteroFields.push(field);
- } else {
- zoteroFields = zoteroFields.concat(field);
- }
-
- var matches;
- for each(var zoteroField in zoteroFields) {
- var value = this.zoteroItem.getField(zoteroField, false, true).toString();
-
- // Quoted strings are never numeric
- if(value.match(Zotero.CSL._quotedRegexp)) {
- continue;
- }
-
- var matches;
- if(value != "" && (matches = value.match(Zotero.CSL._numberRegexp)) ) {
- value = matches[0];
- if (form == "ordinal") {
- return this.makeOrdinal(value);
- }
- else if (form == "roman") {
- return this.makeRoman(value);
- }
- else
- return value;
- }
- }
- return "";
-}
-
-/*
- * Sets an item-specific property to a given value.
- */
-Zotero.CSL.Item.prototype.setProperty = function(property, value) {
- this._properties[property] = value;
-}
-
-/*
- * Sets an item-specific property to a given value.
- */
-Zotero.CSL.Item.prototype.getProperty = function(property, value) {
- return (this._properties[property] !== undefined ? this._properties[property] : "");
-}
-
-Zotero.CSL.Item._optionalTypeMap = {
- journalArticle:"article-journal",
- magazineArticle:"article-magazine",
- newspaperArticle:"article-newspaper",
- thesis:"thesis",
- conferencePaper:"paper-conference",
- letter:"personal_communication",
- manuscript:"manuscript",
- interview:"interview",
- film:"motion_picture",
- artwork:"graphic",
- webpage:"webpage",
- report:"report",
- bill:"bill",
- case:"legal_case",
- hearing:"bill", // ??
- patent:"patent",
- statute:"bill", // ??
- email:"personal_communication",
- map:"map",
- blogPost:"webpage",
- instantMessage:"personal_communication",
- forumPost:"webpage",
- audioRecording:"song", // ??
- presentation:"speech",
- videoRecording:"motion_picture",
- tvBroadcast:"broadcast",
- radioBroadcast:"broadcast",
- podcast:"song", // ??
- computerProgram:"book" // ??
-};
-
-// TODO: check with Elena/APA/MLA on this
-Zotero.CSL.Item._fallbackTypeMap = {
- book:"book",
- bookSection:"chapter",
- journalArticle:"article",
- magazineArticle:"article",
- newspaperArticle:"article",
- thesis:"article",
- encyclopediaArticle:"chapter",
- dictionaryEntry:"chapter",
- conferencePaper:"chapter",
- letter:"article",
- manuscript:"article",
- interview:"article",
- film:"book",
- artwork:"book",
- webpage:"article",
- report:"book",
- bill:"book",
- case:"book",
- hearing:"book",
- patent:"article",
- statute:"book",
- email:"article",
- map:"article",
- blogPost:"article",
- instantMessage:"article",
- forumPost:"article",
- audioRecording:"book",
- presentation:"article",
- videoRecording:"book",
- tvBroadcast:"article",
- radioBroadcast:"article",
- podcast:"article",
- computerProgram:"book"
-};
-
-/*
- * Determines whether this item is of a given type
- */
-Zotero.CSL.Item.prototype.isType = function(type) {
- var zoteroType = Zotero.ItemTypes.getName(this.zoteroItem.itemTypeID);
-
- return (Zotero.CSL.Item._optionalTypeMap[zoteroType]
- && Zotero.CSL.Item._optionalTypeMap[zoteroType] == type)
- || (Zotero.CSL.Item._fallbackTypeMap[zoteroType] ? Zotero.CSL.Item._fallbackTypeMap[zoteroType] : "article") == type;
-}
-
-/*
- * Separates names into different types.
- */
-Zotero.CSL.Item.prototype._separateNames = function() {
- this._names = [];
-
- var authorID = Zotero.CreatorTypes.getPrimaryIDForType(this.zoteroItem.itemTypeID);
-
- var creators = this.zoteroItem.getCreators();
- for each(var creator in creators) {
- if(creator.creatorTypeID == authorID) {
- var variable = "author";
- } else {
- var variable = Zotero.CreatorTypes.getName(creator.creatorTypeID);
- }
-
- var name = new Zotero.CSL.Item.Name(creator);
-
- if(!this._names[variable]) {
- this._names[variable] = [name];
- } else {
- this._names[variable].push(name);
- }
- }
-}
-
-/*
- * Generates an date object for a given variable (currently supported: issued
- * and accessed)
- */
-Zotero.CSL.Item.prototype._createDate = function(variable) {
- // first, figure out what date variable to use.
- if(variable == "issued") {
- var date = this.zoteroItem.getField("date", false, true);
- var sort = this.zoteroItem.getField("date", true, true);
- } else if(variable == "accessed") {
- var date = this.zoteroItem.getField("accessDate", false, true);
- var sort = this.zoteroItem.getField("accessDate", true, true);
- }
-
- if(date) {
- this._dates[variable] = new Zotero.CSL.Item.Date(date, sort);
- } else {
- this._dates[variable] = false;
- }
-}
-
-/*
- * Date class
- */
-Zotero.CSL.Item.Date = function(date, sort) {
- this.date = date;
- this.sort = sort;
-}
-
-/*
- * Should accept the following variables:
- *
- * year - returns a year (optionally, with attached B.C.)
- * month - returns a month (numeric from 0, or, if numeric is not available, long)
- * day - returns a day (numeric)
- * sort - a date that can be used for sorting purposes
- */
-Zotero.CSL.Item.Date.prototype.getDateVariable = function(variable) {
- if(this.date) {
- if(variable == "sort") {
- return this.sort;
- }
-
- if(!this.dateArray) {
- this.dateArray = Zotero.Date.strToDate(this.date);
- }
-
- if(this.dateArray[variable] !== undefined && this.dateArray[variable] !== false) {
- return this.dateArray[variable];
- } else if(variable == "month") {
- if(this.dateArray.part) {
- return this.dateArray.part;
- }
- }
- }
-
- return "";
-}
-
-/*
- * Name class
- */
-Zotero.CSL.Item.Name = function(zoteroCreator) {
- this._zoteroCreator = zoteroCreator;
-}
-
-/*
- * Should accept the following variables:
- *
- * firstName - first name
- * lastName - last name
- */
-Zotero.CSL.Item.Name.prototype.getNameVariable = function(variable) {
- return this._zoteroCreator.ref[variable] ? this._zoteroCreator.ref[variable] : "";
-}
-
-/*
- * When an array of items are passed to create a new item set, each is wrapped
- * in an item wrapper.
- */
-Zotero.CSL.ItemSet = function(items, csl) {
- default xml namespace = "http://purl.org/net/xbiblio/csl"; with({});
-
- this.csl = csl;
-
- this.citation = csl._csl.citation;
- this.bibliography = csl._csl.bibliography;
-
- // collect options
- this.options = new Object();
- var options = this.citation.option.(@name.substr(0, 12) == "disambiguate")
- + this.bibliography.option.(@name == "subsequent-author-substitute");
- for each(var option in options) {
- this.options[option.@name.toString()] = option.@value.toString();
- }
-
- // check for disambiguate condition
- for each(var thisIf in csl._csl..if) {
- if(thisIf.@disambiguate.length()) {
- this.options["disambiguate-condition"] = true;
- break;
- }
- }
-
- // check for citation number
- for each(var thisText in csl._csl..text) {
- if(thisText.@variable == "citation-number") {
- this.options["citation-number"] = true;
- break;
- }
- }
-
- // set sortable
- this.sortable = !!this.bibliography.sort.key.length();
-
- this.items = [];
- this.itemsById = {};
-
- // add items
- this.add(items);
-
- // check which disambiguation options are enabled
- this._citationChangingOptions = new Array();
- this._disambiguate = false;
- for(var option in this.options) {
- if(option.substr(0, 12) == "disambiguate" && this.options[option]) {
- this._citationChangingOptions.push(option);
- this._disambiguate = true;
- } else if(option == "citation-number" && this.options[option]) {
- this._citationChangingOptions.push(option);
- }
- }
-
- if(!items) {
- return;
- }
-
- this.resort();
-}
-
-
-/**
- * Gets CSL.Item objects from an item set using their ids
- *
- * @param {Array} ids An array of ids
- * @return {Array} items An array whose indexes correspond to those of ids, whose values are either
- * the CSL.Item objects or false
- **/
-Zotero.CSL.ItemSet.prototype.getItemsByIds = function(ids) {
- var items = [];
- for each(var id in ids) {
- if(this.itemsById[id] != undefined) {
- items.push(this.itemsById[id]);
- } else {
- items.push(false);
- }
- }
- return items;
-}
-
-/*
- * Adds items to the given item set; must be passed either CSL.Item
- * objects or objects that may be wrapped as CSL.Item objects
- */
-Zotero.CSL.ItemSet.prototype.add = function(items) {
- var newItems = new Array();
-
- for(var i in items) {
- if(items[i] instanceof Zotero.CSL.Item) {
- var newItem = items[i];
- } else {
- var newItem = new Zotero.CSL.Item(items[i]);
- }
-
- newItem.setProperty("index", this.items.length);
-
- this.itemsById[newItem.id] = newItem;
- this.items.push(newItem);
- newItems.push(newItem);
- }
-
- return newItems;
-}
-
-/*
- * Removes items from the item set; must be passed either CSL.Item objects
- * or item IDs
- */
-Zotero.CSL.ItemSet.prototype.remove = function(items) {
- for(var i in items) {
- if(!items[i]) continue;
- if(items[i] instanceof Zotero.CSL.Item) {
- var item = items[i];
- } else {
- var item = this.itemsById[items[i]];
- }
- if(item) {
- this.itemsById[item.id] = undefined;
- this.items.splice(this.items.indexOf(item), 1);
- }
- }
-}
-
-/*
- * Sorts the item set, also running postprocessing and returning items whose
- * citations have changed
- */
-Zotero.CSL.ItemSet.prototype.resort = function() {
- default xml namespace = "http://purl.org/net/xbiblio/csl"; with({});
-
- // sort
- this.items = this.csl.cachedSort(this.items, this.bibliography);
-
- // first loop through to collect disambiguation data by item, so we can
- // see if any items have changed; also collect last names
- var oldOptions = new Array();
- for(var i in this._citationChangingOptions) {
- oldOptions[i] = new Array();
- for(var j in this.items) {
- if(this.items[j] == undefined) continue;
- oldOptions[i][j] = this.items[j].getProperty(this._citationChangingOptions[i]);
- this.items[j].setProperty(this._citationChangingOptions[i], "");
- }
- }
-
- var namesByItem = new Object();
- for(var i=0; i 1) {
- // have two items with identical last names but different
- // first names
- nameType[lastName] = Zotero.CSL.NAME_USE_INITIAL;
-
- // check initials to see if any match
- var initials = new Object();
- for(var k=0; k lastNames.length) {
- numberOfNames = lastNames.length;
- item.setProperty("disambiguate-add-names", numberOfNames+1);
-
- // have to check old property
- if(!oldAddNames || oldAddNames < numberOfNames) {
- lastItem.setProperty("disambiguate-add-names", numberOfNames);
- }
-
- disambiguated = true;
- } else if(numberOfNames != lastNames.length) {
- item.setProperty("disambiguate-add-names", numberOfNames);
-
- // have to check old property
- if(!oldAddNames || oldAddNames < numberOfNames+1) {
- lastItem.setProperty("disambiguate-add-names", numberOfNames+1);
- }
-
- disambiguated = true;
- }
- }
-
- // now, loop through and see whether there's a
- // dissimilarity before the end
- var namesDiffer = false;
- for(var j=0; j= 1) {
- var nonZCharCode = lastDisambiguate.charCodeAt(newDisambiguate.length-1);
- newDisambiguate = newDisambiguate.substring(0,newDisambiguate.length-1);
- newDisambiguate += String.fromCharCode(nonZCharCode+1);
- for(i=0;i 1) {
- strings[i] = strings[i][0].toUpperCase()+strings[i].substr(1).toLowerCase();
- } else if(strings[i].length == 1) {
- strings[i] = strings[i].toUpperCase();
- }
- }
- string = strings.join(" ");
- } else if(element["@text-case"] == "title") {
- string = Zotero.Text.titleCase(string);
- }
- }
-
- // style attributes
- if(this.format == "HTML") {
- var style = "";
-
- var cssAttributes = ["font-family", "font-style", "font-variant",
- "font-weight", "vertical-align", "display",
- "text-decoration" ];
- for(var j in cssAttributes) {
- var value = element["@"+cssAttributes[j]].toString();
- if(value && value.indexOf('"') == -1) {
- style += cssAttributes[j]+":"+value+";";
- }
- }
-
- if(style) {
- addBefore += '';
- addAfter = ''+addAfter;
- }
- } else {
- if(this.format == "RTF" || this.format == "Integration") {
- var rtfAttributes = {
- "font-style":{"oblique":"i", "italic":"i"},
- "font-variant":{"small-caps":"scaps"},
- "font-weight":{"bold":"b"},
- "text-decoration":{"underline":"ul"},
- "vertical-align":{"sup":"super", "sub":"sub"}
- }
-
- for(var j in rtfAttributes) {
- for(var k in rtfAttributes[j]) {
- if(element["@"+j] == k) {
- addBefore += "\\"+rtfAttributes[j][k]+" ";
- addAfter = "\\"+rtfAttributes[j][k]+"0 "+addAfter;
- }
- }
- }
- }
- }
-
- // add quotes if necessary
- if(element.@quotes == "true") {
- this.string += this._openQuote;
-
- if(this.useBritishStyleQuotes) {
- string += this._closeQuote;
- } else {
- this.closePunctuation = this._closeQuote;
- }
- }
- }
-
- if(!dontEscape) {
- if(this.format == "HTML") {
- string = string.replace("&", "&", "g")
- .replace("<", "<", "g")
- .replace(">", ">", "g")
- .replace(/(\r\n|\r|\n)/g, "
")
- .replace(/[\x00-\x1F]/g, "");
- } else if(this.format == "RTF" || this.format == "Integration") {
- string = string.replace("\\", "\\\\", "g")
- .replace(/(\r\n|\r|\n)/g, "\\line ");
- if(string.substr(string.length-6) == "\\line ") {
- string = string.substr(0, string.length-6);
- addAfter = "\\line "+addAfter;
- }
-
- if(this.format == "RTF") {
- string = string.replace(/[{}\x7F-\uFFFF]/g, Zotero.CSL.FormattedString._rtfEscapeFunction)
- .replace("\t", "\\tab ", "g");
-
- if(string.substr(string.length-5) == "\\tab ") {
- string = string.substr(0, string.length-5);
- addAfter = "\\tab "+addAfter;
- }
- }
- } else {
- string = string.replace(/(\r\n|\r|\n)/g, (Zotero.isWin ? "\r\n" : "\n"));
- }
- }
-
- this.string += addBefore+string;
-
- if(element && element.@suffix.length()) {
- this.append(element.@suffix.toString(), null, true);
- }
-
- // save for second-field-align
- if(!dontDelimit && this.insertTabAfterField) {
- this.insertTabAfterField = false;
- this.insertTabBeforeField = true;
- }
-
- this.closeFormatting = addAfter;
-
- return true;
-}
-
-/*
- * gets the formatted string
- */
-Zotero.CSL.FormattedString.prototype.get = function() {
- return this.string+this.closeFormatting+this.closePunctuation;
-}
-
-/*
- * creates a new formatted string with the same formatting parameters as this one
- */
-Zotero.CSL.FormattedString.prototype.clone = function(delimiter) {
- return new Zotero.CSL.FormattedString(this.context, this.format, delimiter, true);
-}
-
-/*
- * Implementation of FormattedString for sort purposes.
- */
-Zotero.CSL.SortString = function() {
- default xml namespace = "http://purl.org/net/xbiblio/csl";
-
- this.format = "Sort";
- this.string = [];
-}
-
-Zotero.CSL.SortString.prototype.concat = function(newString) {
- if(newString.string.length == 0) {
- return;
- } else if(newString.string.length == 1) {
- this.string.push(newString.string[0]);
- } else {
- this.string.push(newString.string);
- }
-}
-
-Zotero.CSL.SortString.prototype.append = function(newString) {
- this.string.push(newString);
-}
-
-Zotero.CSL.SortString.prototype.compare = function(b, a) {
- // by default, a is this string
- if(a == undefined) {
- a = this.string;
- b = b.string;
- }
-
- var aIsString = typeof(a) != "object";
- var bIsString = typeof(b) != "object";
- if(aIsString && bIsString) {
- if(a == b) {
- return 0;
- } else if(!isNaN(a % 1) && !isNaN(b % 1)) {
- // both numeric
- if(b > a) return -1;
- return 1; // already know they're not equal
- } else {
- var cmp = Zotero.CSL.Global.collation.compareString(Zotero.CSL.Global.collation.kCollationCaseInSensitive, a, b);
- if(cmp == 0) {
- // for some reason collation service returned 0; the collation
- // service sucks! they can't be equal!
- if(b > a) {
- return -1;
- } else {
- return 1;
- }
- }
- return cmp;
- }
- } else if(aIsString && !bIsString) {
- var cmp = this.compare(b[0], a);
- if(cmp == 0) {
- return -1; // a before b
- }
- return cmp;
- } else if(bIsString && !aIsString) {
- var cmp = this.compare(b, a[0]);
- if(cmp == 0) {
- return 1; // b before a
- }
- return cmp;
- }
-
- var maxLength = Math.min(b.length, a.length);
- for(var i = 0; i < maxLength; i++) {
- var cmp = this.compare(b[i], a[i]);
- if(cmp != 0) {
- return cmp;
- }
- }
-
- if(b.length > a.length) {
- return -1; // a before b
- } else if(b.length < a.length) {
- return 1; // b before a
- }
-
- return 0;
-}
-
-
-Zotero.CSL.SortString.prototype.clone = function() {
- return new Zotero.CSL.SortString();
-}
\ No newline at end of file
diff --git a/chrome/content/zotero/xpcom/integration.js b/chrome/content/zotero/xpcom/integration.js
index 3fd0925896..d3223200cd 100644
--- a/chrome/content/zotero/xpcom/integration.js
+++ b/chrome/content/zotero/xpcom/integration.js
@@ -26,6 +26,7 @@
const RESELECT_KEY_URI = 1;
const RESELECT_KEY_ITEM_KEY = 2;
const RESELECT_KEY_ITEM_ID = 3;
+const DATA_VERSION = 3;
Zotero.Integration = new function() {
var _fifoFile = null;
@@ -222,6 +223,7 @@ Zotero.Integration = new function() {
integration._doc.displayAlert(Zotero.getString("integration.error.generic")+message,
Components.interfaces.zoteroIntegrationDocument.DIALOG_ICON_STOP,
Components.interfaces.zoteroIntegrationDocument.DIALOG_BUTTONS_OK);
+ Zotero.debug(e);
throw e;
}
}
@@ -294,8 +296,11 @@ Zotero.Integration.UserCancelledException.prototype.name = "UserCancelledExcepti
Zotero.Integration.UserCancelledException.prototype.message = "User cancelled document update.";
Zotero.Integration.UserCancelledException.prototype.toString = function() { return this.message; };
-Zotero.Integration.DisplayException = function(name) { this.name = name };
-Zotero.Integration.DisplayException.prototype.toString = function() { return Zotero.getString("integration.error."+this.name); };
+Zotero.Integration.DisplayException = function(name, params) {
+ this.name = name;
+ this.params = params ? params : [];
+};
+Zotero.Integration.DisplayException.prototype.toString = function() { return Zotero.getString("integration.error."+this.name, this.params); };
Zotero.Integration.CorruptFieldException = function(corruptFieldString) {
this.corruptFieldString = corruptFieldString;
@@ -358,14 +363,15 @@ Zotero.Integration.Document.prototype._getSession = function(require, dontRunSet
this._doc.setDocumentData(this._session.data.serializeXML());
}
} else {
- if(dataString[0] != "<") {
+ var data = new Zotero.Integration.DocumentData(dataString);
+ if(data.dataVersion < DATA_VERSION) {
var warning = this._doc.displayAlert(Zotero.getString("integration.upgradeWarning"),
Components.interfaces.zoteroIntegrationDocument.DIALOG_ICON_WARNING,
Components.interfaces.zoteroIntegrationDocument.DIALOG_BUTTONS_OK_CANCEL);
if(!warning) throw new Zotero.Integration.UserCancelledException();
+ } else if(data.dataVersion > DATA_VERSION) {
+ throw new Zotero.Integration.DisplayException("newerDocumentVersion", [data.zoteroVersion, Zotero.version]);
}
-
- var data = new Zotero.Integration.DocumentData(dataString);
if(Zotero.Integration.sessions[data.sessionID]) {
this._session = Zotero.Integration.sessions[data.sessionID];
} else {
@@ -409,7 +415,7 @@ Zotero.Integration.Document.prototype._getFields = function(require) {
while(fields.hasMoreElements()) {
this._fields.push(fields.getNext().QueryInterface(Components.interfaces.zoteroIntegrationField));
}
- var endTime = (new Date()).getTime();;
+ var endTime = (new Date()).getTime();
Zotero.debug("Got "+this._fields.length+" fields in "+(endTime-getFieldsTime)/1000+"; "+1000/((endTime-getFieldsTime)/this._fields.length)+" fields/second");
if(require && !this._fields.length) {
@@ -468,7 +474,7 @@ Zotero.Integration.Document.prototype._updateSession = function(newField, editFi
var fieldCode = field.getCode();
if(fieldCode.substr(0, ITEM_CODE.length) == ITEM_CODE) {
- var noteIndex = (this._session.style.class == "note" ? field.getNoteIndex() : 0);
+ var noteIndex = (this._session.styleClass == "note" ? field.getNoteIndex() : 0);
try {
this._session.addCitation(i, noteIndex, fieldCode.substr(ITEM_CODE.length+1));
} catch(e) {
@@ -582,7 +588,8 @@ Zotero.Integration.Document.prototype._updateSession = function(newField, editFi
}
}
- this._session.updateItemSet();
+ //this._session.updateItems();
+ this._session.updateCitations();
// create new citation or edit existing citation
if(editFieldIndex) {
@@ -602,6 +609,7 @@ Zotero.Integration.Document.prototype._updateSession = function(newField, editFi
}
}
}
+ this._session.updateItems();
}
/**
@@ -632,37 +640,28 @@ Zotero.Integration.Document.prototype._updateDocument = function(forceCitations,
// update citations
this._session.updateUpdateIndices(forceCitations);
- for(var i in this._session.updateIndices) {
+ this._deleteFields = this._deleteFields.concat(this._session.updateCitations());
+ for(var i in this._session.citationText) {
citation = this._session.citationsByIndex[i];
if(!citation) continue;
- if(citation.properties["delete"]) {
- // delete citation
- this._deleteFields.push(i);
+ var fieldCode = this._session.getCitationField(citation);
+ if(fieldCode != citation.properties.field) {
+ this._fields[citation.properties.index].setCode(ITEM_CODE+" "+fieldCode);
+ }
+
+ if(citation.properties.custom) {
+ var citationText = citation.properties.custom;
} else {
- var fieldCode = this._session.getCitationField(citation);
- if(fieldCode != citation.properties.field) {
- this._fields[citation.properties.index].setCode(ITEM_CODE+" "+fieldCode);
- }
-
- if(citation.properties.custom) {
- var citationText = citation.properties.custom;
- // XML uses real RTF, rather than the format used for
- // integration, so we have to escape things properly
- citationText = citationText.replace(/[{}\x7F-\uFFFF]/g,
- Zotero.Integration.Session._rtfEscapeFunction).
- replace("\t", "\\tab ", "g");
- } else {
- var citationText = this._session.style.formatCitation(citation, "RTF");
- }
-
- if(citationText.indexOf("\\") !== -1) {
- // need to set text as RTF
- this._fields[citation.properties.index].setText("{\\rtf "+citationText+"}", true);
- } else {
- // set text as plain
- this._fields[citation.properties.index].setText(citationText, false);
- }
+ var citationText = this._session.citationText[i];
+ }
+
+ if(citationText.indexOf("\\") !== -1) {
+ // need to set text as RTF
+ this._fields[citation.properties.index].setText("{\\rtf "+citationText+"}", true);
+ } else {
+ // set text as plain
+ this._fields[citation.properties.index].setText(citationText, false);
}
}
@@ -713,7 +712,7 @@ Zotero.Integration.Document.prototype.addBibliography = function() {
this._getSession(true);
// Make sure we can have a bibliography
- if(!this._session.style.hasBibliography) {
+ if(!this._session.data.style.hasBibliography) {
throw new Zotero.Integration.DisplayException("noBibliography");
}
@@ -856,7 +855,29 @@ Zotero.Integration.Document.JSEnumerator.prototype.getNext = function() {
Zotero.Integration.Session = function() {
// holds items not in document that should be in bibliography
this.uncitedItems = new Object();
+ this.customBibliographyText = new Object();
this.reselectedItems = new Object();
+ this.citationIDs = new Object();
+}
+
+/**
+ * Resets per-request variables in the CitationSet
+ */
+Zotero.Integration.Session.prototype.resetRequest = function() {
+ this.citationsByItemID = new Object();
+ this.citationsByIndex = new Array();
+ this.uriMap = new Zotero.Integration.URIMap(this);
+
+ this.regenerateAll = false;
+ this.bibliographyHasChanged = false;
+ this.bibliographyDataHasChanged = false;
+ this.updateItemIDs = new Object();
+ this.updateIndices = new Object();
+ this.newIndices = new Object();
+
+ this.oldCitationIDs = this.citationIDs;
+ this.citationIDs = new Object();
+ this.citationText = new Object();
}
/**
@@ -868,12 +889,14 @@ Zotero.Integration.Session.prototype.setData = function(data) {
this.data = data;
if(data.style.styleID && oldStyleID != data.style.styleID) {
this.styleID = data.style.styleID;
+ Zotero.debug("style is "+data.style.styleID);
try {
- this.style = Zotero.Styles.get(data.style.styleID).csl;
+ var getStyle = Zotero.Styles.get(data.style.styleID);
+ data.style.hasBibliography = getStyle.hasBibliography;
+ this.style = getStyle.csl;
+ this.style.setOutputFormat("rtf");
+ this.styleClass = getStyle.class;
this.dateModified = new Object();
-
- this.itemSet = this.style.createItemSet();
- this.loadUncitedItems();
} catch(e) {
Zotero.debug(e)
data.style.styleID = undefined;
@@ -916,7 +939,7 @@ Zotero.Integration.Session.prototype.setDocPrefs = function(primaryFieldType, se
data.prefs.fieldType = io.fieldType;
this.setData(data);
// need to do this after setting the data so that we know if it's a note style
- this.data.prefs.noteType = this.style && this.style.class == "note" ? io.useEndnotes+1 : 0;
+ this.data.prefs.noteType = this.style && this.styleClass == "note" ? io.useEndnotes+1 : 0;
if(!oldData || oldData.style.styleID != data.style.styleID
|| oldData.prefs.noteType != data.prefs.noteType
@@ -960,71 +983,61 @@ Zotero.Integration.Session.prototype.reselectItem = function(exception) {
}
}
-/**
- * Resets per-request variables in the CitationSet
- */
-Zotero.Integration.Session.prototype.resetRequest = function() {
- this.citationsByItemID = new Object();
- this.citationsByIndex = new Array();
- this.uriMap = new Zotero.Integration.URIMap(this);
-
- this.regenerateAll = false;
- this.bibliographyHasChanged = false;
- this.bibliographyDataHasChanged = false;
- this.updateItemIDs = new Object();
- this.updateIndices = new Object();
-}
-
/**
* Generates a field from a citation object
*/
Zotero.Integration.Session._acceptableTypes = ["string", "boolean", "number"];
Zotero.Integration.Session._saveProperties = ["custom", "sort"];
+Zotero.Integration.Session._saveItems = ["locator", "label", "suppress-author", "author-only", "prefix", "suffix"];
Zotero.Integration.Session.prototype.getCitationField = function(citation) {
- var type, field = "";
+ var type;
+ var field = [];
+ field.push('"citationID":'+Zotero.JSON.serialize(citation.citationID));
+ var properties = [];
for(var j=0; j= citation.properties.index
- ? Zotero.CSL.POSITION_FIRST : Zotero.CSL.POSITION_SUBSEQUENT);
-
- // update if desired
- if(update && (citation.citationItems[i].position || newPosition) && citation.citationItems[i].position != newPosition) {
- this.updateIndices[citation.properties.index] = true;
- }
- citation.citationItems[i].position = newPosition;
- }
- }
-}
-
-/**
- * Updates the ItemSet, adding and deleting bibliography items as appropriate, then re-sorting
- */
-Zotero.Integration.Session.prototype.updateItemSet = function() {
- var deleteItems = [];
- var missingItems = [];
-
- // see if items were deleted from Zotero
- for(var i in this.citationsByItemID) {
- if (!Zotero.Items.get(i)) {
- deleteItems.push(i);
- missingItems.push(i);
- }
- }
-
- // see if old items were deleted or changed
- for each(var item in this.itemSet.items) {
- var itemID = item.id;
-
- // see if items were removed
- if(!this.citationsByItemID[itemID] && !this.uncitedItems[itemID]) {
- deleteItems.push(itemID);
- continue;
- }
-
- if(item.zoteroItem && this.dateModified[itemID] != item.zoteroItem.getField("dateModified", true, true)) {
- // update date modified
- this.dateModified[itemID] = item.zoteroItem.getField("dateModified", true, true);
- // add to list of updated item IDs
- this.updateItemIDs[itemID] = true;
- }
- }
-
- // delete items from item set
- if(deleteItems.length) {
- this.itemSet.remove(deleteItems);
- this.bibliographyHasChanged = true;
- }
-
- this.sortItemSet();
-}
-
-/**
- * Sorts the ItemSet
- */
-Zotero.Integration.Session.prototype.sortItemSet = function() {
- // save first index
- for(var itemID in this.citationsByItemID) {
- if(this.citationsByItemID[itemID]) {
- var item = this.itemSet.getItemsByIds([itemID])[0];
- if(item) item.setProperty("index", this.citationsByItemID[itemID][0].properties.index);
- }
- }
-
- var citationChanged = this.itemSet.resort();
-
- // add to list of updated item IDs
- for each(var item in citationChanged) {
- this.updateItemIDs[item.id] = true;
- this.bibliographyHasChanged = true;
- }
-}
-
-/**
- * Edits integration bibliography
- */
-Zotero.Integration.Session.prototype.editBibliography = function() {
- var bibliographyEditor = new Zotero.Integration.Session.BibliographyEditInterface(this);
- var io = new function() { this.wrappedJSObject = bibliographyEditor; }
-
- this.bibliographyDataHasChanged = this.bibliographyHasChanged = true;
-
- var window = Components.classes["@mozilla.org/embedcomp/window-watcher;1"]
- .getService(Components.interfaces.nsIWindowWatcher)
- .openWindow(null, 'chrome://zotero/content/integration/editBibliographyDialog.xul', '',
- 'chrome,centerscreen,resizable', io, true);
- while(!window.closed) Zotero.mainThread.processNextEvent(true);
+ this.updateIndices[index] = true;
}
/**
@@ -1450,13 +1265,46 @@ Zotero.Integration.Session.prototype.editBibliography = function() {
*/
Zotero.Integration.Session.prototype.getBibliography = function() {
// use real RTF, but chop off the first \n
- var text = this.style.formatBibliography(this.itemSet, "RTF")
- var nlIndex = text.indexOf("\n");
- if(nlIndex !== -1) {
- return "{\\rtf "+text.substr(text.indexOf("\n"));
- } else {
- return "";
- }
+ return Zotero.Cite.makeFormattedBibliography(this.style, "rtf", this.customBibliographyText);
+}
+
+/**
+ * Calls CSL.Engine.updateItems() to reconcile item list with current items in document
+ */
+Zotero.Integration.Session.prototype.updateItems = function() {
+ var items = [[i, this.citationsByItemID[i][0]] for(i in this.citationsByItemID)
+ if(this.citationsByItemID[i] && this.citationsByItemID[i].length &&
+ this.citationsByItemID[i].some(function(citation) citation.properties && !citation.properties.delete))];
+
+ items.sort(function(a, b) {
+ // if first citation of each in different citations, use citation index
+ if(a[1].properties.index != b[1].properties.index) {
+ return a[1].properties.index-b[1].properties.index;
+ }
+
+ // if a and b were both first cited in the same citation, look for index in the citation
+ for each(var citationItem in a[1].citationItems) {
+ if(citationItem.id == a[0]) {
+ return -1;
+ } else if(citationItem.id == b[0]) {
+ return 1;
+ }
+ }
+
+ // should never happen
+ Zotero.debug("WARNING: Zotero.Integration.Session.updateItems sort function returned 0");
+ return 0;
+ });
+
+ // get rid of the second part of the items (the first citation, used for sort purposes)
+ // and also add in the uncited items
+ items = [parseInt(item[0]) for each(item in items)].concat([parseInt(i) for(i in this.uncitedItems)]);
+
+ //Zotero.debug("items are ");
+ //Zotero.debug(items);
+
+ // set items in the bibliography
+ this.style.updateItems(items);
}
/**
@@ -1480,8 +1328,70 @@ Zotero.Integration.Session.prototype.updateUpdateIndices = function(regenerateAl
}
}
-Zotero.Integration.Session._rtfEscapeFunction = function(aChar) {
- return "{\\uc0\\u"+aChar.charCodeAt(0).toString()+"}"
+/**
+ * Returns a formatted citation
+ */
+Zotero.Integration.Session.prototype.formatCitation = function(index, citation) {
+ if(!this.citationText[index]) {
+ //this.updateItems();
+ var citationIndices = [];
+ var citationsPre = [];
+ for(var i=0; i 1);
+ }
+}
+
+/**
+ * Updates the list of citations to be serialized to the document
+ */
+Zotero.Integration.Session.prototype.updateCitations = function() {
+ Zotero.debug("Zotero.Integration: indices of new citations");
+ Zotero.debug([key for(key in this.newIndices)]);
+ Zotero.debug("Zotero.Integration: indices of updated citations");
+ Zotero.debug([key for(key in this.updateIndices)]);
+ var deleteCitations = [];
+ for each(var indexList in [this.newIndices, this.updateIndices]) {
+ for(var index in indexList) {
+ index = parseInt(index, 10);
+ var citation = this.citationsByIndex[index];
+ if(citation.properties.delete) {
+ deleteCitations.push(index);
+ continue;
+ }
+ if(this.formatCitation(index, citation)) {
+ this.bibliographyHasChanged = true;
+ }
+ if(!this.citationIDs[citation.citationID]) {
+ this.citationIDs[citation.citationID] = citation;
+ }
+ delete this.newIndices[index];
+ }
+ }
+
+ return deleteCitations;
}
/**
@@ -1519,8 +1429,6 @@ Zotero.Integration.Session.prototype.loadBibliographyData = function(json) {
}
}
- this.loadUncitedItems();
-
// set custom bibliography entries
if(documentData.custom) {
if(documentData.custom[0]) {
@@ -1531,11 +1439,9 @@ Zotero.Integration.Session.prototype.loadBibliographyData = function(json) {
if(!zoteroItem) continue;
if(needUpdate) this.bibliographyDataHasChanged = true;
- var item = this.itemSet.getItemsByIds([zoteroItem.id])[0];
- if(!item) continue;
-
- item.setProperty("bibliography-Integration", custom[1]);
- item.setProperty("bibliography-RTF", custom[1]);
+ if(this.citationsByItemID[zoteroItem.id] || this.uncitedItems[zoteroItem.id]) {
+ this.customBibliographyText[zoteroItem.id] = custom[1];
+ }
}
} else {
// old style hash
@@ -1544,10 +1450,9 @@ Zotero.Integration.Session.prototype.loadBibliographyData = function(json) {
if(!zoteroItem) zoteroItem = Zotero.Items.get(itemID);
if(!zoteroItem) continue;
- var item = this.itemSet.getItemsByIds([zoteroItem.id])[0];
- if (!item) continue;
- item.setProperty("bibliography-Integration", documentData.custom[itemID]);
- item.setProperty("bibliography-RTF", documentData.custom[itemID]);
+ if(this.citationsByItemID[zoteroItem.id] || this.uncitedItems[zoteroItem.id]) {
+ this.customBibliographyText[zoteroItem.id] = documentData.custom[itemID];
+ }
}
this.bibliographyDataHasChanged = true;
}
@@ -1556,21 +1461,6 @@ Zotero.Integration.Session.prototype.loadBibliographyData = function(json) {
this.bibliographyData = json;
}
-/**
- * Adds items in this.uncitedItems to itemSet, if they are not already there
- */
-Zotero.Integration.Session.prototype.loadUncitedItems = function() {
- for(var itemID in this.uncitedItems) {
- // skip "undefined"
- if(!this.uncitedItems[itemID]) continue;
- var item = this.itemSet.getItemsByIds([itemID])[0];
- if(!item) {
- var zoteroItem = Zotero.Items.get(itemID);
- if(zoteroItem) this.itemSet.add([zoteroItem]);
- }
- }
-}
-
/**
* Saves document data from a JSON object
*/
@@ -1586,17 +1476,8 @@ Zotero.Integration.Session.prototype.getBibliographyData = function() {
}
// look for custom bibliography entries
- if(this.itemSet.items.length) {
- for(var i=0; i
+ var xmlData =
;
@@ -1719,6 +1684,8 @@ Zotero.Integration.DocumentData.prototype.unserializeXML = function(xmlData) {
for each(var pref in xmlData.prefs.children()) {
this.prefs[pref.@name.toString()] = pref.@value.toString();
}
+ this.zoteroVersion = xmlData["@zotero-version"].length() ? xmlData["@zotero-version"].toString() : "2.0";
+ this.dataVersion = xmlData["@data-version"].length() ? xmlData["@data-version"].toString() : 2;
}
/**
@@ -1749,6 +1716,9 @@ Zotero.Integration.DocumentData.prototype.unserialize = function(input) {
} else {
this.prefs.noteType = 0;
}
+
+ this.zoteroVersion = "2.0b6 or earlier";
+ this.dataVersion = 1;
}
}
diff --git a/chrome/content/zotero/xpcom/quickCopy.js b/chrome/content/zotero/xpcom/quickCopy.js
index 057afd1057..696b70acc6 100644
--- a/chrome/content/zotero/xpcom/quickCopy.js
+++ b/chrome/content/zotero/xpcom/quickCopy.js
@@ -391,28 +391,21 @@ Zotero.QuickCopy = new function() {
}
var csl = Zotero.Styles.get(format).csl;
- var itemSet = csl.createItemSet(items);
+ csl.updateItems([item.id for each(item in items)]);
// Copy citations if shift key pressed
if (modified) {
- var itemIDs = [];
- for (var i=0; i]*\?>\s*\n/g, "");
+ var ret = new XML(str);
+ return ret;
+ }
/**
* Finishes installing a style, copying the file, reloading the style cache, and refreshing the
@@ -346,20 +353,13 @@ Zotero.Style = function(file) {
this.type = "csl";
- var xml = Zotero.CSL.Global.cleanXML(Zotero.File.getContents(file));
- try {
- xml = new XML(xml);
- } catch(e) {
- Zotero.log(e.toString(), "error",
- Zotero.Styles.ios.newFileURI(this.file).spec, xml.split(/\r?\n/)[e.lineNumber-1],
- e.lineNumber);
- return;
- }
+ var xml = Zotero.Styles.cleanXML(Zotero.File.getContents(file));
this.styleID = xml.info.id.toString();
this.title = xml.info.title.toString();
this.updated = xml.info.updated.toString().replace(/(.+)T([^\+]+)\+?.*/, "$1 $2");
this._class = xml.@class.toString();
+ this._hasBibliography = !!xml.bibliography.length();
this.source = null;
for each(var link in xml.info.link) {
@@ -381,22 +381,57 @@ Zotero.Style.prototype.__defineGetter__("csl",
* @type Zotero.CSL
*/
function() {
- // cache last style
- if(Zotero.Styles.cacheTranslatorData && Zotero.Styles.lastCSL &&
- Zotero.Styles.lastCSL.styleID == this.styleID) {
- return Zotero.Styles.lastCSL;
+ var locale = Zotero.Prefs.get('export.bibliographyLocale');
+ if(!locale) {
+ var locale = Zotero.locale;
+ if(!locale) {
+ var locale = 'en-US';
+ }
}
+ return new Zotero.CiteProc.CSL.Engine(Zotero.Cite.System, this.getXML(), Zotero.locale);
+});
+
+Zotero.Style.prototype.__defineGetter__("class",
+/**
+ * Retrieves the style class, either from the metadata that's already loaded or by loading the file
+ * @type String
+ */
+function() {
+ if(!this._class) this.getXML();
+ return this._class;
+});
+
+Zotero.Style.prototype.__defineGetter__("hasBibliography",
+/**
+ * Determines whether or not this style has a bibliography, either from the metadata that's already\
+ * loaded or by loading the file
+ * @type String
+ */
+function() {
+ if(!this._hasBibliography) this.getXML();
+ return this._hasBibliography;
+});
+
+/**
+ * Retrieves the XML corresponding to this style
+ * @type String
+ */
+Zotero.Style.prototype.getXML = function() {
+ // "with ({});" needed to fix default namespace scope issue
+ // See https://bugzilla.mozilla.org/show_bug.cgi?id=330572
+ default xml namespace = "http://purl.org/net/xbiblio/csl"; with ({});
+
if(this.type == "ens") {
// EN style
var string = Zotero.File.getBinaryContents(this.file);
var enConverter = new Zotero.ENConverter(string, null, this.title);
var xml = enConverter.parse();
- } else {
- // "with ({});" needed to fix default namespace scope issue
- // See https://bugzilla.mozilla.org/show_bug.cgi?id=330572
- default xml namespace = "http://purl.org/net/xbiblio/csl"; with ({});
+ this._class = xml.@class.toString();
+ this._hasBibliography = !!xml.bibliography.length();
+ return XML.toXMLString();
+ } else {
if(this.source) {
// parent/child
var formatCSL = Zotero.Styles.get(this.source);
@@ -409,22 +444,9 @@ function() {
var file = this.file;
}
- var cslString = Zotero.File.getContents(file);
- var xml = new XML(Zotero.CSL.Global.cleanXML(cslString));
+ return Zotero.File.getContents(file);
}
-
- return (Zotero.Styles.lastCSL = new Zotero.CSL(xml));
-});
-
-Zotero.Style.prototype.__defineGetter__("class",
-/**
- * Retrieves the style class, either from the metadata that's already loaded or by loading the file
- * @type String
- */
-function() {
- if(this._class) return this._class;
- return (this._class = this.csl.class);
-});
+};
/**
* Deletes a style
diff --git a/chrome/content/zotero/xpcom/zotero.js b/chrome/content/zotero/xpcom/zotero.js
index 60aaecfc17..cedec20ea9 100644
--- a/chrome/content/zotero/xpcom/zotero.js
+++ b/chrome/content/zotero/xpcom/zotero.js
@@ -1943,8 +1943,8 @@ Zotero.Date = new function(){
var months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul',
'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];
// If using a non-English bibliography locale, try those too
- if (Zotero.CSL.Global.locale != 'en-US') {
- months = months.concat(Zotero.CSL.Global.getMonthStrings("short"));
+ if (Zotero.locale != 'en-US') {
+ months = months.concat(Zotero.Cite.getMonthStrings("short"));
}
if(!_monthRe) {
_monthRe = new RegExp("^(.*)\\b("+months.join("|")+")[^ ]*(?: (.*)$|$)", "i");
@@ -2020,7 +2020,7 @@ Zotero.Date = new function(){
string += date.part+" ";
}
- var months = Zotero.CSL.Global.getMonthStrings("long");
+ var months = Zotero.Cite.getMonthStrings("long");
if(date.month != undefined && months[date.month]) {
// get short month strings from CSL interpreter
string += months[date.month];
diff --git a/chrome/locale/en-US/zotero/zotero.properties b/chrome/locale/en-US/zotero/zotero.properties
index 6396df396c..0cad8e1227 100644
--- a/chrome/locale/en-US/zotero/zotero.properties
+++ b/chrome/locale/en-US/zotero/zotero.properties
@@ -575,7 +575,8 @@ integration.missingItem.single = This item no longer exists in your Zotero dat
integration.missingItem.multiple = Item %1$S in this citation no longer exists in your Zotero database. Do you want to select a substitute item?
integration.missingItem.description = Clicking "No" will delete the field codes for citations containing this item, preserving the citation text but deleting it from your bibliography.
integration.removeCodesWarning = Removing field codes will prevent Zotero from updating citations and bibliographies in this document. Are you sure you want to continue?
-integration.upgradeWarning = Your document must be permanently upgraded in order to work with Zotero 2.0b7 or later. It is recommended that you make a backup before proceeding. Are you sure you want to continue?
+integration.upgradeWarning = Your document must be permanently upgraded in order to work with Zotero 2.1 or later. It is recommended that you make a backup before proceeding. Are you sure you want to continue?
+integration.error.newerDocumentVersion = Your document was created with a newer version of Zotero (%1$S) than the currently installed version (%1$S). Please upgrade Zotero before editing this document.
integration.corruptField = The Zotero field code corresponding to this citation, which tells Zotero which item in your library this citation represents, has been corrupted. Would you like to reselect the item?
integration.corruptField.description = Clicking "No" will delete the field codes for citations containing this item, preserving the citation text but potentially deleting it from your bibliography.
integration.corruptBibliography = The Zotero field code for your bibliography is corrupted. Should Zotero clear this field code and generate a new bibliography?
diff --git a/chrome/skin/default/zotero/timeline/bundle.js b/chrome/skin/default/zotero/timeline/bundle.js
index b23f699c6b..6cd0b539de 100644
--- a/chrome/skin/default/zotero/timeline/bundle.js
+++ b/chrome/skin/default/zotero/timeline/bundle.js
@@ -233,7 +233,7 @@ Timeline.GregorianDateLabeller=function(locale,timeZone){this._locale=locale;thi
Modified by Ben for Zotero
*/
-Timeline.GregorianDateLabeller.monthNames = Zotero.CSL.Global.getMonthStrings("short");
+Timeline.GregorianDateLabeller.monthNames = Zotero.Cite.getMonthStrings("short");
Timeline.GregorianDateLabeller.getMonthName=function(month,locale) {
return Timeline.GregorianDateLabeller.monthNames[month];
};
diff --git a/components/zotero-service.js b/components/zotero-service.js
index 8dafdb9f25..4d9138b167 100644
--- a/components/zotero-service.js
+++ b/components/zotero-service.js
@@ -18,9 +18,9 @@ var xpcomFiles = [
'zotero',
'annotate',
'attachments',
+ 'cite',
'collectionTreeView',
'commons',
- 'csl',
'dataServer',
'data_access',
'data/dataObjects',
@@ -74,7 +74,17 @@ var xpcomFiles = [
'zeroconf'
];
-for (var i=0; i