',
+'uniquefichedisplay':' '
+}
+};
+
+/* global Scrutari */
+
+function SCRUTARI_FRAMEWORKINIT (scrutariClient) {
+
+ scrutariClient.functions.modalAction = function ($modal, action) {
+ switch(action) {
+ case 'show':
+ if (!$modal.data("overlayId")) {
+ var overlayId = Scrutari.Overlay.start({
+ header: $modal.children("header").html(),
+ content: $modal.children("div").html(),
+ footer: $modal.children("footer").html(),
+ closeTooltip: scrutariClient.loc("_ button_close"),
+ afterEnd: function () {
+ $modal.data("overlayId", null);
+ }
+ });
+ $modal.data("overlayId", overlayId);
+ }
+ break;
+ case 'hide':
+ Scrutari.Overlay.end($modal);
+ break;
+ }
+
+ };
+
+}
+
+Scrutari.Overlay = {};
+
+Scrutari.Overlay.idNumber = 1;
+Scrutari.Overlay.activeInfoArray = new Array();
+
+$(document).on('keydown.overlay', function(event) {
+ if (event.which === 27) {
+ var length = Scrutari.Overlay.activeInfoArray.length;
+ if (length > 0) {
+ var overlayInfo = Scrutari.Overlay.activeInfoArray[length - 1];
+ if (overlayInfo.escapeClose) {
+ Scrutari.Overlay.end(overlayInfo.overlayId);
+ }
+ }
+ }
+});
+
+Scrutari.Overlay.Info = function (overlayId, escapeClose) {
+ this.overlayId = overlayId;
+ this.escapeClose = escapeClose;
+};
+
+Scrutari.Overlay.start = function (settings) {
+ var closeTooltip = "Close";
+ if (settings.closeTooltip) {
+ closeTooltip = settings.closeTooltip;
+ }
+ var overlayIdNumber = Scrutari.Overlay.idNumber;
+ Scrutari.Overlay.idNumber++;
+ var overlayId = "none-overlay_" + overlayIdNumber;
+ Scrutari.Overlay.activeInfoArray.push(new Scrutari.Overlay.Info(overlayId, _checkSetting("escapeClose")));
+ var $overlayBlocker = $("").attr("id", overlayId).attr("class", _getClass("Blocker")).attr("data-role", "overlay");
+ var $overlayDialog = $("").attr("class", _getClass("Dialog")).appendTo($overlayBlocker);
+ $overlayDialog.data("overlayId", overlayId);
+ $("body")
+ .append($overlayBlocker)
+ .css('overflow','hidden');
+ var overlayBody = _getDiv("Header") + _getDiv("Content") + _getDiv("Footer");
+ var includeForm = false;
+ if (settings.formAttrs || settings.ajaxForm || settings.formSubmit) {
+ includeForm = true;
+ var $form = $("");
+ if (settings.formAttrs) {
+ for(var prop in settings.formAttrs) {
+ $form.attr(prop, settings.formAttrs[prop]);
+ }
+ }
+ if (settings.ajaxForm) {
+ var initialBeforeSubmit = settings.ajaxForm.beforeSubmit;
+ settings.ajaxForm.beforeSubmit = function (arr, $form, options) {
+ if ((initialBeforeSubmit) && (initialBeforeSubmit(arr, $form, options) === false)) {
+ return false;
+ }
+ _startWaiting();
+ };
+ var initialSuccess = settings.ajaxForm.success;
+ settings.ajaxForm.success = function (data, textStatus, jqXHR, $form) {
+ _endWaiting();
+ initialSuccess(data, textStatus, jqXHR, $form);
+ };
+ $form.ajaxForm(settings.ajaxForm);
+ } else if (settings.formSubmit) {
+ $form.submit(function () {
+ return settings.formSubmit($(this));
+ });
+ }
+ $overlayDialog.append($form.html(overlayBody));
+ $form.data("overlayId", overlayId);
+ } else {
+ $overlayDialog.html(overlayBody);
+ }
+ _setContent("Header", settings.header);
+ _setContent("Content", settings.content);
+ _setContent("Footer", settings.footer);
+ var clickClose = _checkSetting("clickClose");
+ var showClose = _checkSetting("showClose");
+ $overlayBlocker
+ .click(function() {
+ if (clickClose) {
+ Scrutari.Overlay.end(overlayId);
+ }
+ })
+ .data("beforeEnd", settings.beforeEnd)
+ .data("afterEnd", settings.afterEnd)
+ .css("z-index", 10000 + overlayIdNumber);
+ if (showClose) {
+ $overlayDialog
+ .append("")
+ .on("click.overlay", "[data-role='close']", function () {
+ Scrutari.Overlay.end(overlayId);
+ });
+ }
+ $overlayDialog
+ .click(function (event) {
+ event.stopPropagation();
+ });
+ if (settings.isWaiting) {
+ _startWaiting();
+ }
+ $overlayBlocker.fadeIn(function () {
+ $overlayDialog.show();
+ if (settings.afterStart) {
+ settings.afterStart($overlayDialog);
+ } else if (includeForm) {
+ $overlayDialog.find(":input").filter("[type!='hidden']").first().trigger("focus");
+ }
+ });
+
+ return overlayId;
+
+ function _checkSetting(propName) {
+ if (settings.hasOwnProperty(propName)) {
+ return settings[propName];
+ }
+ return true;
+ }
+
+ function _setContent (name, content) {
+ let $element = $("#" + _getId(name));
+ if (!content) {
+ $element.empty();
+ } else if (content.jquery) {
+ $element.empty().append(content);
+ } else {
+ $element.empty().html(content);
+ }
+ }
+
+ function _startWaiting() {
+ $overlayBlocker.find("[type='submit']").prop("disabled", true);
+ $overlayBlocker.addClass(_getClass("Waiting"));
+ }
+
+ function _endWaiting() {
+ $overlayBlocker.find("[type='submit']").prop("disabled", false);
+ $overlayBlocker.removeClass(_getClass("Waiting"));
+ }
+
+ function _getDiv(name) {
+ return "";
+ }
+
+ function _getId(name) {
+ return overlayId + "_" + name;
+ }
+
+ function _getClass(suffix) {
+ let prefix = "none-overlay-";
+ if (settings.classPrefix) {
+ prefix = settings.classPrefix;
+ }
+ return prefix + suffix;
+ }
+};
+
+Scrutari.Overlay.end = function (overlayId, callback) {
+ if (overlayId.jquery) {
+ overlayId = overlayId.data("overlayId");
+ }
+ if (!overlayId) {
+ return;
+ }
+ var $overlayBlocker = $("#" + overlayId);
+ var beforeEnd = $overlayBlocker.data("beforeEnd");
+ if (beforeEnd) {
+ var result = beforeEnd($overlayBlocker.children("div"));
+ if (result === false) {
+ return;
+ }
+ }
+ _pop();
+ $overlayBlocker.empty();
+ var afterEnd = $overlayBlocker.data("afterEnd");
+ $overlayBlocker.fadeOut(function() {
+ $("#" + overlayId).remove();
+ if ($("body").children("[data-role='overlay']").length === 0) {
+ $("body").css('overflow','');
+ }
+ if (afterEnd) {
+ afterEnd();
+ }
+ if (callback) {
+ callback();
+ }
+ });
+
+ function _pop() {
+ for(var i = 0, len = Scrutari.Overlay.activeInfoArray.length; i < len; i++) {
+ var overlayInfo = Scrutari.Overlay.activeInfoArray[i];
+ if (overlayInfo.overlayId === overlayId) {
+ Scrutari.Overlay.activeInfoArray.splice(i, 1);
+ break;
+ }
+ }
+ }
+};
+
diff --git a/squelettes/javascript/scrutarijs/images/ajax-loader.gif b/squelettes/javascript/scrutarijs/images/ajax-loader.gif
new file mode 100644
index 0000000..6caba22
Binary files /dev/null and b/squelettes/javascript/scrutarijs/images/ajax-loader.gif differ
diff --git a/squelettes/javascript/scrutarijs/images/export_atom.png b/squelettes/javascript/scrutarijs/images/export_atom.png
new file mode 100644
index 0000000..eb47e19
Binary files /dev/null and b/squelettes/javascript/scrutarijs/images/export_atom.png differ
diff --git a/squelettes/javascript/scrutarijs/images/export_ods.png b/squelettes/javascript/scrutarijs/images/export_ods.png
new file mode 100644
index 0000000..df164ff
Binary files /dev/null and b/squelettes/javascript/scrutarijs/images/export_ods.png differ
diff --git a/squelettes/javascript/scrutarijs/images/logo-scrutari.png b/squelettes/javascript/scrutarijs/images/logo-scrutari.png
new file mode 100644
index 0000000..622e873
Binary files /dev/null and b/squelettes/javascript/scrutarijs/images/logo-scrutari.png differ
diff --git a/squelettes/javascript/scrutarijs/l10n/de.js b/squelettes/javascript/scrutarijs/l10n/de.js
new file mode 100644
index 0000000..138d2b7
--- /dev/null
+++ b/squelettes/javascript/scrutarijs/l10n/de.js
@@ -0,0 +1,70 @@
+var SCRUTARI_L10N = {
+lang:'de',
+'_ advice_complexity':'Bitte überprüfen, ob die Suche vereinfacht werden kann',
+'_ and':'UND',
+'_ button_check_all':'Alle überprüfen',
+'_ button_close':'Schließen',
+'_ button_filter_off':'Schalten Sie den Filter aus',
+'_ button_filter_on':'Filter einschalten',
+'_ button_parameters':'Filter und Optionen',
+'_ button_remove':'Entfernen',
+'_ button_submit':'Suche',
+'_ button_uncheck_all':'Alle deaktivieren',
+'_ colon':':',
+'_ error.empty.parametervalue':'Fehler: Die Suche hat nur sinnlose Zeichen!',
+'_ error.empty.searchtoken':'Leerer Suchbegriff',
+'_ error.unknown.attribute':'Unbekannte Eigenschaft',
+'_ error.unknown.fichesearchresult':'Such-ID unbekannt',
+'_ error.unknown.operandtype':'Operandentyp unbekannt',
+'_ error.unknown.scope':'Unbekanntes Feld',
+'_ error.wrong.missingword':'Fehlendes Wort',
+'_ error.wrong.notletterordigitcharacter':'Falsches Zeichen',
+'_ error.wrong.operand_add':'Fehlerhafter Operand',
+'_ error.wrong.operand_date':'Ungültiges Datum',
+'_ error.wrong.operationsyntax':'Syntaxfehler in der erweiterten Suche',
+'_ error.wrong.unclosedquote':'nicht geschlossene Anführungszeichen',
+'_ error.wrong.unexpectedspace':'Unerwartetes Leerzeichen',
+'_ fiche_motscles_many':'Schlüsselwörter:',
+'_ fiche_motscles_one':'Stichwort:',
+'_ filter_off':'[aus]',
+'_ filter_on':'[auf]',
+'_ link_atom':'Feed im Atom Format',
+'_ link_ods':'Tabelle im ODS-Format',
+'_ link_permalink':'Fester Link',
+'_ link_poweredby':'Search powered by Scrutari',
+'_ loading_pagination':'Laden…',
+'_ loading_search':'Suchen ...',
+'_ mode_help':'Hilfe zu Beziehungen zwischen Suchbegriffen',
+'_ mode_intersection':'Und',
+'_ mode_operation':'Fortgeschritten',
+'_ mode_title':'Beziehung zwischen Begriffen:',
+'_ mode_union':'Oder',
+'_ or':'ODER',
+'_ periode_help':'Hilfe zur Begrenzung auf einen Zeitraum',
+'_ periode_title':'Begrenzt auf einen Zeitraum:',
+'_ ponderation_date':'Datum',
+'_ ponderation_help':'Hilfe zur Klassifizierungspriorität',
+'_ ponderation_pertinence':'Relevanz',
+'_ ponderation_title':'Klassifizierungspriorität\u00A0:',
+'_ result_none':'Keine Ergebnisse für die angeforderte Suche',
+'_ stats_filter_short':'Filter:',
+'_ stats_filter_title':'Anzahl der Referenzen, auf die die Suche auf der Basis der aktiven Filter zutrifft',
+'_ stats_global_short':'Gesamt:',
+'_ stats_global_title':'Gesamtzahl der Referenzen in der Suchmaschine',
+'_ stats_result_short':'Ergebnis:',
+'_ stats_result_title':'Anzahl der Referenzen, die die Suchkriterien beantworten',
+'_ title_download':'Abrufen aller Referenzen:',
+'_ title_filter_base':'Datenbankfilter',
+'_ title_filter_category':'Dokumenttypfilter',
+'_ title_filter_corpus':'Korpusfilter',
+'_ title_filter_lang':'Sprachfilter',
+'_ title_history':'Suchverlauf:',
+'_ title_main':'Scrutari-Suche',
+'_ title_options':'Suchoptionen',
+'_ title_share':'Suchresultate weiterleiten:',
+'_ title_subsearch':'Suche nach den letzten Ergebnissen:',
+'_ wildchar_end':'"*" Wird automatisch am Ende des Wortes hinzugefügt',
+'_ help_mode.html':'
Einfache Suche (Und/ OderOptionen): die Leerzeichen sind Begrenzer für die Suchbegriffe; Wenn die Option Und ausgewählt ist, muss eine Referenz alle Suchbegriffe enthalten; Wenn die ausgewählte Option das Oder ist, muss eine Referenz mindestens einen der Begriffe enthalten.
Das Sternchen * kennzeichnet eine Trunkierung (Verkürzung):
gov*: alle Wörter, die mit « gov » beginnen
*logy: alle Wörter, die mit « logy » enden
*eco*: alle Wörter die « eco » beinhalten
Wenn die Option « * » automatisch an das Ende des Wortes anhängen aktiviert ist, werden alle Wörter eine Trunkierung rechts haben (sofern sie nicht in Anführungszeichen stehen).
Wir verwenden gerade Anführungszeichen um eine Folge von Wörtern zu bestimmen. Es ist möglich, Trunkierungen innerhalb von Anführungszeichen einzugeben:
"organic farming": ignoriert den Begriff « organic », wenn er nicht vom Begriff « farming » gefolgt wird
"part": sucht nur nach dem Wort « part », auch wenn das automatische Sternchen rechts aktiviert ist
"pub* pol*": sucht nach Folgen eines Wortes beginnend mit « pub » und gefolgt von einem Wort beginnend mit « pol »
Es gelten folgende Regeln:
Die Suche berücksichtigt keine Akzente und Großbuchstaben
Zeichen die keine Buchstaben oder Ziffern sind, werden ignoriert
Die Suchmaschine schlägt keine Korrekturen für Tippfehler und Rechtschreibfehler vor
Die Suchmaschine indexiert in den Referenzen keine Wörter mit einem oder zwei Buchstaben, wie, weit gebräuchliche Wörter, die nicht signifikant sind in einer bestimmten Sprache ("les, avec, par" wird in Französisch ignoriert, « the » wird in Englisch ignoriert aber nicht nicht in Französisch - um die Suche nach der Silbe « thé » zu berücksichtigen)
Erweiterte Suche (Option « Erweitert » (Advanced)): Die erweiterte Suche verwendet die gleichen Prinzipien wie die einfache Syntaxsuche (Sternchen * für Trunkierungen, Anführungszeichen für Folgen), aber das Leerzeichen ist kein Trennzeichen mehr; Stattdessen verwenden wir drei Operatoren:
&&: Und (And)
||: Oder (Or)
!: Nein (No)
Wir verwenden Klammern, um logische Gruppen zu bilden.
Beispiele:
farming &&~!organic: sucht nach Referenzen, die ein Wort enthalten, das mit farming beginnt und keine Wörter enthält, die mit organisch beginnen
farming &&~!(organic || country): sucht nach Referenzen, die ein Wort enthalten, das mit farming beginnt und weder Wörter die mit organic beginnen, noch Wörter die mit country beginnen, enthält
Alle Syntaxfehler (einschließlich der Verwendung von anderen Zeichen als Zahlen, nicht zugelassene Buchstaben und Leerzeichen zum Trennen von Wörtern nicht in Anführungszeichen) erzeugen eine Fehlermeldung.
Es ist möglich, die Suche nach einem Wort auf ein gegebenes Feld durch Präfixieren eines Begriffs zu beschränken. Mögliche Präfixe sind:
title: (Titel) = nur in Titeln
subtitle: (Untertitel) = nur in Untertiteln
keyword: (Stichwort) = nur in Stichworten
additional: (Zusätzlich) = in « zusätzlichen » Feldern (ergänzende Felder und Attribute)
Alle Attributnamen gefolgt von (all attribute names followed by): durch die Suchmaschine definiert (z. B. sct:authors: aber es hängt von der Suchmaschine ab)
Beispiele:
title:governance: « governance » nur im Titel
sct:authors:« Victor Hugo »: Suche nach dem Autor Victor Hugo (wenn das Attribut sct:authors: richtig durch die Suchmaschine definiert ist)
title:pol* &&~!sct:authors:Smith: Referenz mit einem Wort, das mit « pol » im Titel beginnt und dessen Autor nicht Smith ist
Dieses Feld wird verwendet, um die Referenzen auf diejenigen zu beschränken, die einem bestimmten Zeitraum entsprechen. Es ist möglich zu spezifizieren:
Ein bestimmtes Jahr: 2014
Einen Zeitraum, der mehrere Jahre umfasst, unter Verwendung des Schrägstrichs / als Trennzeichen: 2000/2011
Einen bestimmten Monat: 2014-01
Einen Zeitraum, der mit einem bestimmten Monat beginnt und endet: 2013 / 2014-04
Mehrere verschiedene Zeiträume, indem man sie mit zwei vertikalen Strichen || von einander trennt ("ODER" (OR) - Operator): 2001/2002 || 2005 || 2012-11
Es ist anzumerken, dass häufig nur das Jahr einer gegebenen Referenz bekannt ist. Das bedeutet, dass bei bestimmten Konfigurationen die Angabe des Monats keine Ergebnisse liefert.
',
+'_ help_ponderation.html':'
Die Konfiguration der Rangfolgepriorität beeinflusst die Reihenfolge der angezeigten Ergebnisse folgendermaßen:
Rangfolge nach Relevanz: Vorrang erhalten jene Referenzen, die die Suchbegriffe in den Hauptfeldern (Titel, Untertitel) anstatt in den sekundären Feldern beinhalten, und mit Vorrang, wenn sie auch in den Stichworten vorhanden sind.
Das Datum spielt jedoch eine Rolle bei der Entscheidung zwischen gleichen Rangfolgen von Relevanz. Darüber hinaus, wenn Suchmaschinen mehrere Datenbanken absuchen, die Rangfolge könnte sich leicht ändern, um übermäßig lange Reihen von Referenzen aus der gleichen Datenbank zu vermeiden;
Rangfolge nach Datum: Wie durch den Namen erklärt, ist das der Fall, wenn die jüngsten Referenzen zuerst positioniert sind, mit der Relevanz als den entscheidenden Faktor, wenn das Datum sehr ähnlich ist; Referenzen ohne Datum erscheinen am Ende.
'
+};
diff --git a/squelettes/javascript/scrutarijs/l10n/en.js b/squelettes/javascript/scrutarijs/l10n/en.js
new file mode 100644
index 0000000..b71aaad
--- /dev/null
+++ b/squelettes/javascript/scrutarijs/l10n/en.js
@@ -0,0 +1,71 @@
+var SCRUTARI_L10N = {
+lang:'en',
+'_ advice_complexity':'Check if you can simplify the search',
+'_ and':'AND',
+'_ button_check_all':'Check all',
+'_ button_close':'Close',
+'_ button_filter_off':'Turn filter off',
+'_ button_filter_on':'Turn filter on',
+'_ button_parameters':'Filters and options',
+'_ button_remove':'Remove',
+'_ button_submit':'Search',
+'_ button_uncheck_all':'Uncheck all',
+'_ colon':':',
+'_ error.empty.parametervalue':'Error: the search only has meaningless characters!',
+'_ error.empty.searchtoken':'Empty search term',
+'_ error.unknown.attribute':'Unknown attribute',
+'_ error.unknown.fichesearchresult':'Search ID unknown',
+'_ error.unknown.operandtype':'Operand type unknown',
+'_ error.unknown.scope':'Unknown field',
+'_ error.wrong.missingword':'Missing word',
+'_ error.wrong.notletterordigitcharacter':'Incorrect character',
+'_ error.wrong.operand_add':'Malformed operand',
+'_ error.wrong.operand_date':'Malformed date',
+'_ error.wrong.operationsyntax':'Syntax error in the advanced search',
+'_ error.wrong.unclosedquote':'Unclosed quote',
+'_ error.wrong.unexpectedspace':'Unexpected space',
+'_ fiche_motscles_many':'Keywords:',
+'_ fiche_motscles_one':'Keyword:',
+'_ filter_off':'[off]',
+'_ filter_on':'[on]',
+'_ link_atom':'ATOM feed',
+'_ link_ods':'Table in ODS format',
+'_ link_permalink':'Permalink',
+'_ link_poweredby':'Search powered by Scrutari',
+'_ loading_pagination':'Loading…',
+'_ loading_search':'Searching…',
+'_ mode_help':'Help on relationships between search terms',
+'_ mode_intersection':'And',
+'_ mode_operation':'Advanced',
+'_ mode_title':'Relationship between terms:',
+'_ mode_union':'Or',
+'_ or':'OR',
+'_ periode_help':'Help on limiting to a period',
+'_ periode_title':'Limited to a period:',
+'_ ponderation_date':'Date',
+'_ ponderation_help':'Help on classification priority',
+'_ ponderation_pertinence':'Relevance',
+'_ ponderation_title':'Classification priority:',
+'_ result_none':'No results for the requested search',
+'_ stats_filter_short':'Filter:',
+'_ stats_filter_title':'Number of references the search will apply to on the basis of the active filters',
+'_ stats_global_short':'Total:',
+'_ stats_global_title':'Total number of references in the search engine',
+'_ stats_result_short':'Result:',
+'_ stats_result_title':'Number of references that answer the search criteria',
+'_ title_download':'Retrieving all references:',
+'_ title_filter_base':'Database filter',
+'_ title_filter_category':'Document type filter',
+'_ title_filter_corpus':'Corpus filter',
+'_ title_filter_lang':'Language filter',
+'_ title_history':'Search\u00A0history:',
+'_ title_main':'Scrutari search',
+'_ title_options':'Search options\u00A0',
+'_ title_share':'Share:',
+'_ title_subsearch':'Searching latest results:',
+'_ wildchar_end':'“*” is added automatically at the end of the word',
+'_ button_subsearch':'Filter',
+'_ help_mode.html':'
Simple search (And / Oroptions): the spaces are delimiters for the search terms; if the option And is selected, a reference has to include all the search terms; if the selected option is Or, a reference has to include at least one of the terms.
The asterisk * indicates a truncation:
gov*: all words beginning with “gov”
*logy: all words ending in “logy”
*eco*: all words including “eco”
If the option “*” automatically added to the end of the word is ticked, all the words are considered to have a truncation on the right (unless they are in quotation marks).
We use straight quotation marks to indicate a sequence of words. It is possible to indicate truncations inside quotation marks:
"organic farming": ignores the term organic if it is not followed by farming
"part": only searches for the word “part” even if the automatic asterisk to the right is activated
"pub* pol*": search for sequences of a word beginning with “pub” followed by a word beginning with “pol”
The following rules apply:
searches do not take accents and uppercase letters into account
characters other than letters and figures are ignored
the search engine does not propose corrections for typing errors and spelling mistakes
the search engine does not index in the references words with one or two letters, such as common words which are not significant in a given language (“les, avec, par” will be ignored in French, “the” is ignored in English but not in French, to include searches on the term “thé”)
Advanced search (“Advanced” option): the advanced search uses the same principles as the simple search in terms of syntax (asterisk * for truncations, quotation marks for sequences) but the space is no longer a delimiter; instead, we use three operators:
&&: And
||: Or
!: No
We use brackets to form logical groups.
Examples:
farming &&~!organic: searches for references containing a word beginning with farming and not containing any words beginning with organic
farming &&~!(organic || country): searches for references containing a word beginning with farming and not containing either words beginning with organic or words beginning with country
All syntax errors (including the use of characters other than numbers, unauthorized letters and a space for separating words not in quotation marks) produce an error message.
It is possible to restrict the search for a word to a given field by prefixing a term. Possible prefixes are:
title: = only in titles
subtitle: = only in subtitles
keyword: = only in keywords
additional: = in “additional” fields (complementary fields and attributes)
all attribute names followed by : defined by the search engine (e.g. sct:authors: but it depends on the engine used)
Examples:
title:governance: “governance” only in the title
sct:authors:"Victor Hugo": search for the author Victor Hugo (if the attribute sct:authors is properly defined by the engine)
title:pol* &&~!sct:authors:Smith: reference with a word beginning with “pol” in the title and whose author is not Smith
See Search syntax on the Scrutari website (in french)
',
+'_ help_periode.html':'
This field is used to restrict references to those that correspond to a given period. It is possible to specify:
a particular year: 2014
a period covering several years by using the slash mark / as a delimiter: 2000/2011
a particular month: 2014-01
a period beginning and ending with a particular month: 2013/2014-04
several different periods, by separating them with two vertical bars || (“OR” operator): 2001/2002||2005||2012-11
It is worth noting that, frequently, only the year of a given reference is known. This means that in certain configurations, specifying the month will not produce any results.
',
+'_ help_ponderation.html':'
Configuration of ranking priority will affect the order results are displayed in:
ranking by relevance: priority is given to references containing the search terms in the main fields (title, subtitle) rather than secondary fields, with a premium when it is also present in the keywords.
The date does, however, play a role in deciding on similar ratings by relevance. In addition, when engines search several databases, ranking may be slightly altered to avoid overly long series of references from the same database;
ranking by date: as explained by the name, this is when the most recent references are positioned first, with relevance as the deciding factor when dates are very similar; references without dates are at the end.
'
+};
diff --git a/squelettes/javascript/scrutarijs/l10n/es.js b/squelettes/javascript/scrutarijs/l10n/es.js
new file mode 100644
index 0000000..69ebfcd
--- /dev/null
+++ b/squelettes/javascript/scrutarijs/l10n/es.js
@@ -0,0 +1,83 @@
+var SCRUTARI_L10N = {
+lang:'es',
+'_ advice_complexity':'Averiguar si no pueden simplificar la búsqueda',
+'_ and':'Y',
+'_ button_check_all':'Marcar todo',
+'_ button_close':'Cerrar',
+'_ button_filter_off':'Desactivar el filtro',
+'_ button_filter_on':'Activar el filtro',
+'_ button_parameters':'Filtros y opciones',
+'_ button_remove':'Suprimir',
+'_ button_resubmit':'Volver a lanzar la búsqueda',
+'_ button_submit':'Buscar',
+'_ button_uncheck_all':'Desmarcar todo',
+'_ colon':':',
+'_ error.empty.parametervalue':'Error\u00A0: la búsqueda está constituida sólo de carácteres no significativos\u00A0!',
+'_ error.empty.searchtoken':'Término de búsqueda vacio',
+'_ error.unknown.attribute':'Atributo desconocido',
+'_ error.unknown.fichesearchresult':'Número de búsqueda desconocido',
+'_ error.unknown.operandtype':'Tipo de operand desconocido',
+'_ error.unknown.scope':'Campo desconocido',
+'_ error.wrong.missingword':'Palabra Faltante',
+'_ error.wrong.notletterordigitcharacter':'Carácter incorrecto',
+'_ error.wrong.operand_add':'Operand mal formado',
+'_ error.wrong.operand_date':'Fecha mal formada',
+'_ error.wrong.operationsyntax':'Error de sintaxis en la búsqueda avanzada',
+'_ error.wrong.unclosedquote':'Comillas mal cerradas',
+'_ error.wrong.unexpectedspace':'Espacio inesperado',
+'_ fiche_motscles_many':'Palabras-claves:',
+'_ fiche_motscles_one':'Palabra-clave:',
+'_ filter_off':'[desactivado]',
+'_ filter_on':'[activado]',
+'_ label_base_many':'Bases',
+'_ label_base_one':'Bases',
+'_ label_category_many':'Categorias',
+'_ label_category_one':'Categoria',
+'_ label_corpus_many':'Corpus',
+'_ label_corpus_one':'Corpus',
+'_ label_lang_many':'Idiomas',
+'_ label_lang_one':'Idioma',
+'_ link_atom':'Flujo de sindicación ATOM',
+'_ link_csv':'Planilla del formato CSV',
+'_ link_ods':'Planilla en el formato ODS',
+'_ link_permalink':'Permalink hacia la búsqueda en curso',
+'_ link_poweredby':'Búsqueda con Scrutari',
+'_ loading_pagination':'Cargando...',
+'_ loading_search':'Búsqueda en curso...',
+'_ mode_help':'Ayuda para las relaciones entre los términos de búsqueda',
+'_ mode_intersection':'Y',
+'_ mode_operation':'Avanzada',
+'_ mode_title':'Relación entre los términos',
+'_ mode_union':'O',
+'_ or':'O',
+'_ periode_help':'Ayuda para la limitación a un período',
+'_ periode_title':'Limitado a un periodo',
+'_ ponderation_date':'Fecha',
+'_ ponderation_help':'Ayuda para la prioridad en la clasificación',
+'_ ponderation_pertinence':'Pertinencia',
+'_ ponderation_title':'Prioridad en la clasificación',
+'_ result_none':'Ningun resultado para la búsqueda pedida',
+'_ stats_filter_short':'Filtro\u00A0:',
+'_ stats_filter_title':'Número de referencias sobre las que se hará la búsqueda por los filtros activos',
+'_ stats_global_short':'Total\u00A0:',
+'_ stats_global_title':'Número total de referencias en el motor de búsqueda',
+'_ stats_result_short':'Resultado\u00A0:',
+'_ stats_result_title':'Número de referencias que responden a los criterios de búsqueda',
+'_ title_download':'Recuperación de la integralidad de las referencias',
+'_ title_feed':'Suscribirse a la búsqueda :',
+'_ title_filter_base':'Aplicar filtro sobre las bases de datos',
+'_ title_filter_category':'Aplicar filtro sobre las categorias',
+'_ title_filter_corpus':'Aplicar filtro sobre los corpus',
+'_ title_filter_lang':'Aplicar filtro sobre los idiomas',
+'_ title_history':'Histórico de la búsqueda',
+'_ title_main':'Búsqueda Scrutari',
+'_ title_options':'Opciones de búsqueda',
+'_ title_share':'Compartir la búsqueda:',
+'_ title_subsearch':'Búsqueda sobre los resultados de la búsqueda en curso:',
+'_ wildchar_end':'«\u202F*\u202F» añadido en forma automática al final de las palabras',
+'_ button_subsearch':'Filtrar',
+'_ result_fitlerwarning':'Recordatorio: actualmente hay un filtro activo',
+'_ help_mode.html':'
Búsqueda simple (Opciones Y / O): Los espacios sirven de delimitadores a las palabras de la búsqueda ; si la opción Y está seleccionada, una referencia tendrá que poseer todas las palabras de la búsqueda ; si la opción es O, una referencia tendrá que poseer por lo menos una de ellas.
El asterisco * es el carácter que indica que la palabra está truncada :
gob* : todas las palabras que empiezan por “gob”
*logía : todas las palabras que terminan por “logia”
*eco* : todas las palabras que contienen “eco”
Si la opción :“*”, añadida en forma automática al final de las palabras está marcada con una cruz, se considera que todas las palabras están truncadas a la derecha (excepto si están entre comillas).
Se utiliza las comillas inglesas para indicar una secuencia de palabras. Es posible indicar truncamientos dentro de las comillas :
"agricultura biológica" : ignora el término agricultura si no está seguido de biológica
"part" : busca únicamente en la palabra “part”incluso si la opción de asterisco a la derecha automática está activada
"pol*pub*" : busca las secuencias de una palabra que empieza por “pol” seguida de una palabra que empieza por “pub”
Finalmente se aplican las reglas siguientes :
la búsqueda no toma en cuenta los acentos ni las mayúsculas
se ignoran los caracteres distintos de las letras y las cifras
el motor de búsqueda no propone correcciones de los errores de tipeo y de ortografía
el motor de búsqueda no indexa en las referencias las palabras de una o dos letras, así como las palabras corrientes que no tienen significado en sí en uno u otro idioma (se ignorarán“los/las, con, por”en castellano, “the” se ignora en inglés pero no en francés (búsqueda sobre el té (thé) en francés)
Búsqueda avanzada (Opción “Avanzada”) : la búsqueda avanzada retoma los principios de la búsqueda de palabras por la sintaxis de las palabras (asterisco* para las palabras truncadas, comillas para las secuencias) pero el espacio ya no sirve para separar, se utilizan en su lugar tres operadores :
&& : Y
|| : O
! : No
Se utilizan los paréntesis para formar grupos lógicos.
Ejemplos :
agricultura && !biologica : busca las referencias que contienen una palabra que empieza por agricultura y que no contienen una palabra empezando por biológica
agricultura && !(biologica||pais) : busca las referencias que contienen una palabra que empieza por agricultura y no contienen una palabra empezando por biológica ni una una palabra empezando por país
Todo error de sintaxis (incluso la utilización de caracteres distintos de letras y cifras no autorizadas, el espacio para separar a palabras que no están entre comillas) provoca un mensaje de error.
Es posible reducir para una palabra la búsqueda a un campo dado colocando un prefijo a esta palabra. Los prefijos posibles son :
titulo: = sólo en los títulos
subtitulo: = sólo en los subtítulos
palabraclave: = sólo en las palabras claves
suplemento: = en los campos “suplementarios” (los campos complementarios y los atributos)
todo nombre de atributo seguido de : definido por el motor de búsqueda (por ejemplo, sct:authors: pero esto depende del motor utilizado)
Ejemplos:
titulo:gobernanza : la palabra “gobernanza” sólo en el título
sct:authors:"Garcia Marquez" : Búsqueda sobre el autor García Márquez (si el atributo sct:authors está definido en dicho motor)
titulo:pol*&&!sct:authors:Gómez : referencia con una palabra que empieza por “pol”en el título y cuyo autor no es Gómez
Este campo permite conservar sólo las referencias que corresponden a un período dado. Es posible indicar :
un año preciso : 2014
un período que abarca varios años utilizando una / como separador : 2000/2011
un mes preciso : 2014-01
un período que empieza o se termina en un mes preciso : 2013/2014-04
varios períodos distintos separándolos por || (operador “O”): 2001/2002||2005||2012-11
Notaremos que suele ocurrir que, para une referencia, sólo se conoce el año; en ciertas configuraciones, la indicación de un mes puede provocar una falta de resultados.
',
+'_ help_ponderation.html':'
La configuración de la prioridad en la clasificación va a influir el orden de presentación de los resultados :
Clasificación por pertinencia : se otorga la prioridad a las referencias que contienen los términos buscados en los campos principales (título, subtítulo) más que en los campos secundarios con una prima cuando se encuentran también en las palabras-claves.
La fecha cumple sin embargo un papel para las prioridades en las notas de pertinencia cercanas. E incluso, en el caso donde los motores actúan en varias bases de datos, la clasificación puede verse ligeramente alterada para evitar series de referencias demasiado largas desde una sola base.
Clasificación por fecha : como su nombre lo indica, se colocan las referencias las más recientes en primer lugar, la pertinencia cumple un papel de árbitro para las fechas cercanas; las referencias sin fecha se encuentran al final.
'
+};
diff --git a/squelettes/javascript/scrutarijs/l10n/fr.js b/squelettes/javascript/scrutarijs/l10n/fr.js
new file mode 100644
index 0000000..0ec5390
--- /dev/null
+++ b/squelettes/javascript/scrutarijs/l10n/fr.js
@@ -0,0 +1,83 @@
+var SCRUTARI_L10N = {
+lang:'fr',
+'_ advice_complexity':'Vérifiez si vous ne pouvez pas simplifier la recherche',
+'_ and':'ET',
+'_ button_check_all':'Tout cocher',
+'_ button_close':'Fermer',
+'_ button_filter_off':'Désactiver le filtre',
+'_ button_filter_on':'Activer le filtre',
+'_ button_parameters':'Filtres et options',
+'_ button_remove':'Supprimer',
+'_ button_resubmit':'Relancer la recherche',
+'_ button_submit':'Rechercher',
+'_ button_uncheck_all':'Tout décocher',
+'_ colon':'\u00A0:',
+'_ error.empty.parametervalue':'Erreur\u00A0: la recherche est constituée uniquement de caractères non significatifs\u202F!',
+'_ error.empty.searchtoken':'Terme de recherche vide',
+'_ error.unknown.attribute':'Attribut inconnu',
+'_ error.unknown.fichesearchresult':'Identifiant de recherche inconnu',
+'_ error.unknown.operandtype':'Type d’opérande inconnu',
+'_ error.unknown.scope':'Champ inconnu',
+'_ error.wrong.missingword':'Mot manquant',
+'_ error.wrong.notletterordigitcharacter':'Caractère incorrect',
+'_ error.wrong.operand_add':'Opérande mal formée',
+'_ error.wrong.operand_date':'Date mal formée',
+'_ error.wrong.operationsyntax':'Erreur de syntaxe dans la recherche avancée',
+'_ error.wrong.unclosedquote':'Guillemets mal fermés',
+'_ error.wrong.unexpectedspace':'Espace inattendu',
+'_ fiche_motscles_many':'Mots-clés\u00A0:',
+'_ fiche_motscles_one':'Mot-clé\u00A0:',
+'_ filter_off':'[désactivé]',
+'_ filter_on':'[activé]',
+'_ label_base_many':'Bases',
+'_ label_base_one':'Base',
+'_ label_category_many':'Catégories',
+'_ label_category_one':'Catégorie',
+'_ label_corpus_many':'Corpus',
+'_ label_corpus_one':'Corpus',
+'_ label_lang_many':'Langues',
+'_ label_lang_one':'Langue',
+'_ link_atom':'Flux de syndication ATOM',
+'_ link_csv':'Tableau du format CSV',
+'_ link_ods':'Tableau au format ODS',
+'_ link_permalink':'Permalien vers la recherche en cours',
+'_ link_poweredby':'Recherche effectuée par Scrutari',
+'_ loading_pagination':'Chargement en cours…',
+'_ loading_search':'Recherche en cours…',
+'_ mode_help':'Aide sur les relations entre les termes de recherche',
+'_ mode_intersection':'Et',
+'_ mode_operation':'Avancée',
+'_ mode_title':'Relation entre les termes\u00A0:',
+'_ mode_union':'Ou',
+'_ or':'OU',
+'_ periode_help':'Aide sur la limitation à une période',
+'_ periode_title':'Limité à une période\u00A0:',
+'_ ponderation_date':'Date',
+'_ ponderation_help':'Aide sur la priorité dans le classement',
+'_ ponderation_pertinence':'Pertinence',
+'_ ponderation_title':'Priorité dans le classement :',
+'_ result_none':'Aucun résultat pour la recherche demandée',
+'_ stats_filter_short':'Filtre\u00A0:',
+'_ stats_filter_title':'Nombre de références sur lesquelles se fera la recherche du fait des filtres actifs',
+'_ stats_global_short':'Total\u00A0:',
+'_ stats_global_title':'Nombre total de références dans le moteur',
+'_ stats_result_short':'Résultat\u00A0:',
+'_ stats_result_title':'Nombre de références répondant aux critères de la recherche',
+'_ title_download':'Télécharger les résultats\u00A0:',
+'_ title_feed':'S’abonner à la recherche\u00A0:',
+'_ title_filter_base':'Filtre sur les bases',
+'_ title_filter_category':'Filtre sur les catégories',
+'_ title_filter_corpus':'Filtre sur les corpus',
+'_ title_filter_lang':'Filtre sur les langues',
+'_ title_history':'Historique de recherche\u00A0:',
+'_ title_main':'Recherche Scrutari',
+'_ title_options':'Options de recherche',
+'_ title_share':'URL de la recherche\u00A0:',
+'_ title_subsearch':'Filtrer les résultats par une recherche complémentaire\u00A0:',
+'_ wildchar_end':'«\u202F*\u202F» rajouté automatiquement en fin de mot',
+'_ button_subsearch':'Filtrer',
+'_ result_fitlerwarning':'Rappel\u00A0: un filtre est actif actuellement',
+'_ help_mode.html':'
Recherche simple (Options Et / Ou) : les espaces servent de délimiteurs aux mots de la recherche ; si l’option Et est sélectionné, une référence devra posséder tous le mots de la recherche ; si c’est l’option Ou, une référence devra en posséder au moins un.
L’astérisque * est le caractère indiquant une troncature :
gouv* : tous les mots commençant par « gouv »
*logie : tous les mots finissant par « logie »
*eco* : tous les mots contentant « eco »
Si l’option « * » rajouté automatiquement en fin de mot est cochée, tous les mots sont considérées comme ayant une troncature à droite (sauf s’ils sont entre guillemets).
On utilise les guillemets droits pour indiquer une séquence de mots. Il est possible d’indiquer des troncatures à l’intérieur des guillemets :
"agriculture biologique" : ignore le terme agriculture s’il n’est pas suivi par biologique
"part" : cherche uniquement sur le mot « part » même si l’option d’astérisque à droite automatique est activée
"pol* pub*" : cherche les séquences d’un mot commençant par « pol » suivi d’un mot commençant par « pub »
Enfin les règles suivantes s’appliquent :
la recherche ne tient pas compte des accents et des majuscules
les caractères autres que les lettres et les chiffres sont ignorés
le moteur ne propose pas de corrections des fautes de frappe et d’orthographe
le moteur n’indexe pas dans les références les mots d’une ou deux lettres ainsi que les mots courants non signifiants dans une langue donnée (« les, avec, par » seront ignorés en français, « the » est ignoré en anglais mais pas en français (recherche sur le thé))
Recherche avancée (Option « Avancée ») : la recherche avancée reprend les principes de la recherche des mots pour la syntaxe des mots (astérisque * pour les troncatures, guillemets pour les séquences) mais l’espace ne sert plus de séparateur, on utilise à la place trois opérateurs :
&& : Et
|| : Ou
! : Non
On utilise des parenthèses pour former des groupes logiques.
Exemples :
agriculture && !biologique : cherche les références contenant un mot commençant par agriculture et ne contenant pas de mot commençant par biologique
agriculture && !(biologique || pays) : cherche les références contenant un mot commençant par agriculture et ne contenant ni mot commençant par biologique, ni mot commençant par pays
Tout erreur de syntaxe (y compris l’utilisation de caractères autre que des chiffres et des lettres non autorisés, l’espace pour séparer des mots qui ne sont pas entre guillemets) entraine un message d’erreur.
Il est possible de réduire pour un mot la recherche à un champ donné en préfixant ce mot. Les préfixes possibles sont :
titre: = dans les titres uniquement
soustitre: = dans les sous-titres uniquement
motcle: = dans les mots-clés uniquement
supplement: = dans les champs « supplémentaires » (les champs complémentaires et les attributs)
tout nom d’attribut suivi de : défini par le moteur (par exemple, sct:authors: mais cela dépend du moteur utilisé)
Exemples :
titre:gouvernance : « gouvernance » uniquement dans le titre
sct:authors:"Victor Hugo" : Recherche sur l’auteur Victor Hugo (si l’attribut sct:authors est bien défini par le moteur)
titre:pol* && !sct:authors:Dupont : référence avec un mot commençant par « pol » dans le titre et dont l’auteur n’est pas Dupont
Ce champ permet de ne conserver que les références correspondant à une période donnée. Il est possible d’indiquer :
une année précise : 2014
une période s’étalant sur plusieurs années en utilisant la barre oblique / comme séparateur : 2000/2011
un mois précis : 2014-01
une période commençant ou s’arrêtant à un mois précis : 2013/2014-04
plusieurs périodes différentes en les séparant par deux barres verticales || (opérateur « OU ») : 2001/2002||2005||2012-11
On notera qu’il est fréquent que, pour une référence, seule l’année soit connue ; dans certaines configurations, l’indication d’un mois risque donc de ne donner aucun résultat
',
+'_ help_ponderation.html':'
La configuration de la priorité dans le classement va influer sur l’ordre d’affichage des résultats :
Classement par pertinence : la priorité est donnée aux références contenant les termes recherchés dans les champs principaux (titre, sous-titre) plutôt que dans les champs secondaires avec une prime lorsqu’ils se trouvent également dans les mots-clés.
La date joue tout de même un rôle pour départager des notes de pertinence proches. En outre, dans le cas des moteurs sur plusieurs bases, le classement peut être légèrement altéré pour éviter d’avoir de trop longues séries de références venant d’une seule base.
Classement par date : comme son nom l’indique, les références les plus récentes sont placées en premier, la pertinence jouant un rôle d’arbitre pour les dates proches ; les références non datées se retrouvent à la fin.
'
+};
diff --git a/squelettes/javascript/scrutarijs/l10n/it.js b/squelettes/javascript/scrutarijs/l10n/it.js
new file mode 100644
index 0000000..e5e8dad
--- /dev/null
+++ b/squelettes/javascript/scrutarijs/l10n/it.js
@@ -0,0 +1,83 @@
+var SCRUTARI_L10N = {
+lang:'it',
+'_ advice_complexity':'Verificate se è possibile semplificare la ricerca',
+'_ and':'e',
+'_ button_check_all':'selezionare tutto',
+'_ button_close':'chiudere',
+'_ button_filter_off':'disattivare il filtro',
+'_ button_filter_on':'attivare il filtro',
+'_ button_parameters':'filtri e opzioni',
+'_ button_remove':'cancellare',
+'_ button_resubmit':'Potenziare la ricerca',
+'_ button_submit':'ricerca',
+'_ button_uncheck_all':'deseleziona tutto',
+'_ colon':':',
+'_ error.empty.parametervalue':'errore la ricerca è costituta da caratteri non significativi',
+'_ error.empty.searchtoken':'termine di ricerca vuoto',
+'_ error.unknown.attribute':'attributo sconosciuto',
+'_ error.unknown.fichesearchresult':'identificativo di ricerca sconosciuto',
+'_ error.unknown.operandtype':'tipo di operando sconosciuto',
+'_ error.unknown.scope':'campo sconosciuto',
+'_ error.wrong.missingword':'parola mancante',
+'_ error.wrong.notletterordigitcharacter':'carattere non corretto',
+'_ error.wrong.operand_add':'operando mal costituito',
+'_ error.wrong.operand_date':'data scorretta',
+'_ error.wrong.operationsyntax':'errore di sintassi nella ricerca',
+'_ error.wrong.unclosedquote':'virgolette non chiuse',
+'_ error.wrong.unexpectedspace':'spazio inatteso',
+'_ fiche_motscles_many':'parole chiave:',
+'_ fiche_motscles_one':'parola chiave:',
+'_ filter_off':'[disattivo]',
+'_ filter_on':'[attivo]',
+'_ label_base_many':'Databases',
+'_ label_base_one':'Database',
+'_ label_category_many':'categorie',
+'_ label_category_one':'categoria',
+'_ label_corpus_many':'Corpus',
+'_ label_corpus_one':'Corpus',
+'_ label_lang_many':'Lingue',
+'_ label_lang_one':'Lingua',
+'_ link_atom':'flusso ATOM',
+'_ link_csv':'Tabella di formato CSV',
+'_ link_ods':'cartella formato ODS',
+'_ link_permalink':'Link alla ricerca in corso',
+'_ link_poweredby':'Ricerca realizzata con Scrutari',
+'_ loading_pagination':'caricameto in corso',
+'_ loading_search':'ricerca in corso',
+'_ mode_help':'aiuto per le relazioni tra i termini di ricerca',
+'_ mode_intersection':'e',
+'_ mode_operation':'continuare',
+'_ mode_title':'realzione tra i termini',
+'_ mode_union':'o',
+'_ or':'o',
+'_ periode_help':'aiuto per limitare la ricerca a un periodo',
+'_ periode_title':'limitato a un periodo',
+'_ ponderation_date':'data',
+'_ ponderation_help':'aiuto per la priorità di classificazione',
+'_ ponderation_pertinence':'pertinenza',
+'_ ponderation_title':'priorità di classificazione',
+'_ result_none':'nessun risultato per la ricerca richiesta',
+'_ stats_filter_short':'filtro',
+'_ stats_filter_title':'numero di riferimenti sui quali si farà la ricreca grazie ai filtri attivi',
+'_ stats_global_short':'totale',
+'_ stats_global_title':'numero totale di rinvii nel motore di ricerca',
+'_ stats_result_short':'risultato',
+'_ stats_result_title':'numero di risultati corrispondenti ai criteri di ricerca',
+'_ title_download':'recupero dell’integralità dei risultati',
+'_ title_feed':'Abbonati alla ricerca :',
+'_ title_filter_base':'filtri sulle basi',
+'_ title_filter_category':'filtri sulle categorie',
+'_ title_filter_corpus':'filtri sul corpo del testo',
+'_ title_filter_lang':'filtri sulle lingue',
+'_ title_history':'cronologia della ricerca',
+'_ title_main':'ricerca scrutari',
+'_ title_options':'opzioni di ricerca',
+'_ title_share':'URL di ricerca :',
+'_ title_subsearch':'ricerca sui risultati della ricerca in corso\u00A0:',
+'_ wildchar_end':'«\u00A0*\u00A0» si aggiunge automaticamente alla fine delle parole',
+'_ button_subsearch':'Filtrare',
+'_ result_fitlerwarning':'Avviso: un filtro è attualmente attivo',
+'_ help_mode.html':'
Ricerca semplice (Opzioni e / o) :gli spazi servono a delimitare le parole della ricerca ; se si selziona l’opzione E il rinvio deve contenere tutte le parole della ricerca ; se si seleziona l’opzione O il rinvio deve possedere almeno una parola della ricerca.
L’asterisco * indica una troncatura :
gov* : tutte le parole che cominciano con « gov »
*logia : tutte le parole che finiscono con « logia »
*eco* : tutte le parole che contengono « eco »
Se si seleziona l’opzione « * » aggiunto automaticamente alla fine della parola, tutte le parole saranno da considerarsi con una troncatura a destra (fanno eccezione le parole tra virgolette).
Per indicare una sequenza di termini si usano le virgolette alte. All’interno delle virgolette si possono indicare le troncature :
"agricoltura biologica" : il termine agricoltura viene ignorato se non è seguito dall’aggettivo biologica
"part": cerca solo la parola « part » anche se l’opzione automatica asterisco a destra è attiva
"pol*pub*": cerca le sequenze che contengono una parola che comincia con « pol » seguita da una parola che comincia con « pub »
Per finire valgono le seguenti regole :
la ricerca non considera accenti e maiuscole
i soli caratteri presi in considerazione sono le lettere e le cifre
il motore non propone correzioni in caso di errori di ortografia
il motore non considera le parole di una o due lettere, né le parole di uso corrente ma senza significato proprio ( per esempio : gli, con, per )
Ricerca avanzata ( Opzione « Avanzata ») : la ricerca avanzata usa gli stessi principi della ricerca delle parole ( asterisco * per le troncature, virgolette per le sequenze) ma lo spazio non ha più la funzione di separatore. Al suo posto si usano tre operatori :
&& : E
|| : O
! : No
Per formare gruppi logici si fa ricorso alle parentesi.
Esempi :
agricoltura && !biologica : cerca i risultati che contengono la parola agricoltura non seguita dalla parola biologica
agricoltura && !(biologico || paese) : cerca i risultati che contengono la parola agricoltura et che non contengano la parola biologica o paese.
Gli errori di sintassi (compreso l’uso di caratteri non autorizzati che non siano cifre o lettere, e lo spazio per separare parole non virgolettate) provocano un messaggio di errore.
La ricerca di una parola può essere circoscritta a un campo preciso grazie a un prefisso. I prefissi sono :
titolo: = solo tra i titoli
sottotitolo: = solo tra i sottotitoli
parolachiave: = solo tra le parole chiave
supplemento: = tra i campi supplementari (campi complementari e attributi)
qualsiasi nome di attributo seguito da : definito dal motore ( per sempio : sct:authors. Questo dipende dal motore che si usa.)
Esempi :
titolo:governance : « governance »nel titolo
sct:authors:"Victor Hugo" : Ricerca su l’autore Victor Hugo (se l’attributo sct:authors è definito correttamente dal motore)
titolo:pol* && !sct:authors:Dupont : risultato con, nel titolo, una parola che comincia con « pol » e il cui autore non sia Dupont.
Questo campo permette di conservare i risultati corrispondenti a un periodo preciso. Si possono dare come indicazioni :
un anno : 2014
un periodo di svariati anni servendosi della barra obliqua / per separare le date di inizio e fine : 2000/2011
un mese : 2014-01
un periodo che cominci o finisca ad un mese a scelta : 2013/2014-04
periodi diversi, separati da due due barre verticali || (operatore « O ») : 2001/2002||2005||2012-11
Si noti che, spesso, l’anno è la sola indicazione temporale di un risultato ; in alcune configurazioni, l’indicazione del mese non ottiene nessun risultato.
',
+'_ help_ponderation.html':'
La configuarzione della priorità nella classifica influisce sull’ordine di apparizione dei risultati
Classifica in base alla pertinenza : si da priorità ai risultati che contengono i termini ricercati nei campi principali (titolo, sottotitolo) piuttosto che in quelli secondari. Tra questi hanno priorità i risultati che contengono i termini ricercati tra le parole chiave.
La data aiuta a classificare le note che hanno eguale pertinenza. Inoltre, nel caso di motori di ricerca con più basi, la classifica può essere leggermente alterata per evitare una lunga lista di rinvii proveniente da una sola base.
Classifica per ordine cronologico : i risultati più recenti occupano i primi posti, quando le date sono troppo ravvicinate si fa ricorso al criterio della pertinenza ; i risultati non datati sono collocati alla fine
'
+};
diff --git a/squelettes/javascript/scrutarijs/l10n/pt.js b/squelettes/javascript/scrutarijs/l10n/pt.js
new file mode 100644
index 0000000..b3d87cd
--- /dev/null
+++ b/squelettes/javascript/scrutarijs/l10n/pt.js
@@ -0,0 +1,80 @@
+var SCRUTARI_L10N = {
+lang:'pt',
+'_ advice_complexity':'Descubra se eles não podem simplificar a busca',
+'_ and':'E',
+'_ button_check_all':'Marcar tudo',
+'_ button_close':'Fechar',
+'_ button_filter_off':'Desativar o filtro',
+'_ button_filter_on':'Ativar o filtro',
+'_ button_parameters':'Filtros e opções',
+'_ button_remove':'Eliminar',
+'_ button_resubmit':'Relançar a busca',
+'_ button_submit':'Busca em',
+'_ button_uncheck_all':'Desmarcar tudo',
+'_ colon':':',
+'_ error.empty.parametervalue':'Erro : a busca consiste apenas em caracteres não significativos !',
+'_ error.empty.searchtoken':'Termo de busca vazio',
+'_ error.unknown.attribute':'Atributo desconhecido',
+'_ error.unknown.fichesearchresult':'Número de busca desconhecido',
+'_ error.unknown.operandtype':'Tipo de operando desconhecido',
+'_ error.unknown.scope':'Campo desconhecido',
+'_ error.wrong.missingword':'Palavra que falta',
+'_ error.wrong.notletterordigitcharacter':'Caráter incorreto',
+'_ error.wrong.operand_add':'Operando mal treinado',
+'_ error.wrong.operand_date':'Data incorretamente formada',
+'_ error.wrong.operationsyntax':'Erro de sintaxe na busca avançada',
+'_ error.wrong.unclosedquote':'Vírgulas invertidas incorretamente fechadas',
+'_ error.wrong.unexpectedspace':'Espaço inesperado',
+'_ fiche_motscles_many':'Palavras-chave:',
+'_ fiche_motscles_one':'Palavra-chave:',
+'_ filter_off':'[desabilitado]',
+'_ filter_on':'[ativado]',
+'_ label_base_many':'Bases',
+'_ label_base_one':'Base',
+'_ label_category_many':'Categorias',
+'_ label_category_one':'Categoria',
+'_ label_corpus_many':'Corpus',
+'_ label_corpus_one':'Corpus',
+'_ label_lang_many':'Idiomas',
+'_ label_lang_one':'Idioma',
+'_ link_atom':'Fluxo de sindicação ATOM',
+'_ link_csv':'Tabela do formato CSV',
+'_ link_ods':'Modelo no formato ODS',
+'_ link_permalink':'Link para a busca atual',
+'_ link_poweredby':'Busca com Scrutari',
+'_ loading_pagination':'Em carregamento',
+'_ loading_search':'Busca em progresso...',
+'_ mode_help':'Ajuda para as relações entre termos de busca',
+'_ mode_intersection':'E',
+'_ mode_operation':'Avançada',
+'_ mode_title':'Relação entre os termos',
+'_ mode_union':'Ou',
+'_ or':'Ou',
+'_ periode_help':'Ajuda para a limitação a um período',
+'_ periode_title':'Limitado a um período',
+'_ ponderation_date':'Data',
+'_ ponderation_help':'Ajuda de classificação de prioridades',
+'_ ponderation_pertinence':'Relevância',
+'_ ponderation_title':'Classificação de prioridades',
+'_ result_none':'Nenhum resultado para a busca solicitada',
+'_ stats_filter_short':'Filtro\u00A0:',
+'_ stats_filter_title':'Número de referências a serem pesquisadas pelos filtros ativos',
+'_ stats_global_short':'Total\u00A0:',
+'_ stats_global_title':'Número total de referências no mecanismo de busca',
+'_ stats_result_short':'Resultado\u00A0:',
+'_ stats_result_title':'Número de referências que atendem aos critérios de busca',
+'_ title_download':'Recuperação da integralidade das referências',
+'_ title_feed':'Assine a busca :',
+'_ title_filter_base':'Aplicar filtro em bases de dados',
+'_ title_filter_category':'Aplicar filtro nas categorias',
+'_ title_filter_corpus':'Aplicar filtro nos corpus',
+'_ title_filter_lang':'Aplicar filtro nas idiomas',
+'_ title_history':'Histórico da busca',
+'_ title_main':'Busca Scrutari',
+'_ title_options':'Opções de busca',
+'_ title_share':'Compartilhar a busca:',
+'_ title_subsearch':'Pesquisa sobre os resultados da busca atual:',
+'_ wildchar_end':'«\u202F*\u202F» acrescentado automaticamente no final das palavras',
+'_ button_subsearch':'Filtrar',
+'_ result_fitlerwarning':'Lembrar: atualmente há um filtro ativo'
+};
diff --git a/squelettes/javascript/scrutarijs/perso.css b/squelettes/javascript/scrutarijs/perso.css
new file mode 100644
index 0000000..170cf9c
--- /dev/null
+++ b/squelettes/javascript/scrutarijs/perso.css
@@ -0,0 +1,148 @@
+/*****************************************************
+* .none-input
+******************************************************/
+
+.none-input-Container {
+}
+
+.none-input-Parameters {
+}
+
+.none-input-Search {
+}
+
+.none-input-Submit {
+}
+
+
+/*****************************************************
+* .none-option
+******************************************************/
+
+.none-option-Help {
+}
+
+.none-option-Legend {
+}
+
+.none-option-Title {
+}
+
+/*****************************************************
+* .none-overlay
+******************************************************/
+
+.none-overlay-Blocker {
+ background-color: rgba(0,0,0, 0.75);
+}
+
+.none-overlay-Close {
+ background-color: #000;
+ color: #fff;
+}
+
+.none-overlay-Close:hover {
+ background-color: #ddd;
+}
+
+.none-overlay-Content {
+}
+
+.none-overlay-Dialog {
+ background-color: #fff;
+ box-shadow: 0 0 10px #000;
+}
+
+.none-overlay-Footer {
+}
+
+.none-overlay-Header {
+ border-bottom-color: #ddd;
+ background-color: #f5f5f5;
+}
+
+.none-overlay-Waiting {
+}
+
+
+/*****************************************************
+* .none-panel
+******************************************************/
+
+.none-panel-ButtonGroup {
+}
+
+.none-panel-Columns {
+ padding: 5px;
+}
+
+.none-panel-Header {
+ border-bottom-color: #ddd;
+ background-color: #f5f5f5;
+}
+
+.none-panel-ListBody {
+}
+
+.none-panel-Section {
+ border-color: #ddd;
+}
+
+.texte_content h1.none-panel-Title {
+ font-size: 1.0rem;
+ padding: 3px;
+}
+
+.none-panel-Toolbar {
+}
+
+
+/*****************************************************
+* .none-result
+******************************************************/
+
+.none-result-Container {
+}
+
+.none-result-FicheDisplay {
+}
+
+.none-result-Sidebar {
+}
+
+
+/*****************************************************
+* .scrutari
+******************************************************/
+
+.scrutari-Mark {
+ background-color: #ffe9e0;
+}
+
+.scrutari-fiche-Link {
+ border: 0;
+}
+
+.scrutari-fiche-Titre {
+ font-size: 1.3rem;
+}
+
+.scrutari-fiche-Titre .num_emission {
+ font-size: 1.4rem;
+ margin-right: 0.5rem;
+ padding: 0.2rem;
+ width: inherit;
+}
+
+.scrutari-history-Active {
+ background-color: #ffe9e0;
+}
+
+.scrutari-history-Load {
+ background-color: #ffe9e0;
+ font-family: 'Lato',sans-serif;
+ font-weight: 400;
+ line-height: 1.6;
+ color: #005184;
+ text-rendering: geometricPrecision;
+}
diff --git a/squelettes/javascript/scrutarijs/scrutarijs.css b/squelettes/javascript/scrutarijs/scrutarijs.css
new file mode 100644
index 0000000..2333f1f
--- /dev/null
+++ b/squelettes/javascript/scrutarijs/scrutarijs.css
@@ -0,0 +1,441 @@
+/*****************************************************
+* .scrutari
+******************************************************/
+
+.scrutari-Hidden {
+display: none !important;
+}
+
+.scrutari-Disabled {
+color: grey;
+}
+
+.scrutari-Mark {
+background-color: #e9e9e9;
+}
+
+.scrutari-On {
+}
+
+
+/*****************************************************
+* .scrutari-area
+******************************************************/
+
+.scrutari-area-Parameters {
+margin-top: 5px;
+margin-bottom: 25px;
+}
+
+.scrutari-area-Result {
+margin-bottom: 10px;
+}
+
+.scrutari-area-Stats {
+margin-top: 15px;
+margin-bottom: 15px;
+}
+
+.scrutari-area-Title {
+}
+
+.scrutari-area-Resubmit {
+margin-top: 5px;
+text-align: right;
+}
+
+
+/*****************************************************
+* .scrutari-category
+******************************************************/
+
+.scrutari-category-Tab {
+display: inline-block;
+padding-left: 4px;
+padding-right: 4px;
+cursor: pointer;
+}
+
+.scrutari-category-Tab:hover {
+background-color: #e9e9e9;
+}
+
+.scrutari-category-Tab.scrutari-On {
+cursor: auto;
+background-color: #e9e9e9;
+}
+
+
+/*****************************************************
+* .scrutari-fiche
+******************************************************/
+
+.scrutari-fiche-Attribute {
+margin-left: 15px;
+font-size: 1.0em;
+margin-bottom: 2px;
+}
+
+.scrutari-fiche-AttributeBlock {
+margin-bottom: 2px;
+}
+
+.scrutari-fiche-AttributeTitle {
+margin-left: 15px;
+font-size: 1.0em;
+margin-bottom: 0;
+}
+
+.scrutari-fiche-AttributeValue {
+margin-left: 30px;
+font-size: 1.0em;
+margin-bottom: 0;
+}
+
+.scrutari-fiche-AttributeValues {
+
+}
+
+.scrutari-fiche-AttributeValue::before {
+ content: '… ';
+}
+
+.scrutari-fiche-AttributeValue::after {
+ content: ' …';
+}
+
+.scrutari-fiche-Block {
+margin-bottom: 15px;
+padding-left: 3px;
+}
+
+.scrutari-fiche-Body {
+margin-left: 21px;
+}
+
+.scrutari-fiche-Body.scrutari-fiche-ThumbnailBody {
+margin-left: 110px;
+}
+
+.scrutari-fiche-Body::after {
+content: '';
+display: block;
+clear: left;
+}
+
+.scrutari-fiche-Complement {
+margin-left: 15px;
+font-size: 1.0em;
+margin-bottom: 2px;
+}
+
+.scrutari-fiche-Icon {
+float: left;
+margin-top: 0;
+}
+
+.scrutari-fiche-Motcle {
+font-variant: small-caps;
+font-size: 1.0em;
+margin-left: 15px;
+margin-bottom: 2px;
+}
+
+.scrutari-fiche-Soustitre {
+margin-bottom: 3px;
+font-style: italic;
+margin-left: 10px;
+}
+
+.scrutari-fiche-Thumbnail {
+float: left;
+margin-top: 0;
+position: relative;
+}
+
+.scrutari-fiche-ThumbnailImg {
+max-width: 100px;
+}
+
+.scrutari-fiche-ThumbnailIcon {
+display: block;
+position: absolute;
+top: 0;
+left: 0;
+border-right-color: #fff;
+border-right-style: solid;
+border-right-width: 3px;
+border-bottom-color: #fff;
+border-bottom-style: solid;
+border-bottom-width: 2px;
+background-color: #fff;
+border-bottom-right-radius: 2px;
+z-index: 100;
+}
+
+.scrutari-fiche-Titre {
+font-size: 1.1em;
+margin-bottom: 4px;
+margin-left: 0;
+margin-top: 0;
+}
+
+.scrutari-fiche-Year {
+font-size: 1.0em;
+margin-bottom: 3px;
+font-style: italic;
+margin-left: 15px;
+}
+
+
+/*****************************************************
+* .scrutari-history
+******************************************************/
+
+.scrutari-history-Active {
+background-color: #e9e9e9;
+}
+
+.scrutari-history-Block {
+padding: 2px;
+margin-top: 6px;
+margin-left: 6px;
+word-wrap: break-word;
+}
+
+.scrutari-history-Load {
+
+}
+
+.scrutari-history-Remove {
+
+}
+
+.scrutari-history-Search {
+
+}
+
+.scrutari-history-Subsearch {
+ margin-left: 10px;
+}
+
+/*****************************************************
+* .scrutari-icon
+******************************************************/
+
+.scrutari-icon-Loader {
+background-image: url("images/ajax-loader.gif");
+position: relative;
+display: inline-block;
+width: 16px;
+height: 16px;
+}
+
+.scrutari-icon-Logo {
+background-image: url("images/logo-scrutari.png");
+position: relative;
+bottom: -10px;
+display: inline-block;
+width: 32px;
+height: 32px;
+}
+
+
+/*****************************************************
+* .scrutari-input
+******************************************************/
+
+.scrutari-input-Text {
+border-bottom-left-radius: 4px;
+border-top-left-radius: 4px;
+padding: 2px;
+border-style: solid;
+border-width: 1px;
+border-color: #dfdfdf;
+border-top-color: #a0a0a0;
+border-left-color: #a0a0a0;
+}
+
+
+/*****************************************************
+* .scrutari-label
+******************************************************/
+
+.scrutari-label-Attribute {
+font-style: italic;
+}
+
+.scrutari-label-Complement {
+font-style: italic;
+}
+
+.scrutari-label-Motcle {
+font-style: italic;
+font-variant: normal;
+}
+
+
+/*****************************************************
+* .scrutari-links
+******************************************************/
+
+.scrutari-links-ButtonLike {
+display: inline-block;
+padding-top: 2px;
+padding-right: 5px;
+padding-left: 5px;
+border-radius: 3px;
+border-style: solid;
+border-width: 1px;
+border-color: #a0a0a0;
+margin-right: 5px;
+color: #515151;
+}
+
+.scrutari-links-ButtonLike:visited {
+color: #515151;
+}
+
+.scrutari-links-ButtonLike:hover {
+background-color: #dfdfdf;
+color: #515151;
+text-decoration: none;
+}
+
+.scrutari-links-Permalink {
+text-overflow: ellipsis;
+white-space: nowrap;
+overflow: hidden;
+}
+
+.scrutari-links-Permalink:hover {
+white-space: normal;
+overflow-wrap: break-word;
+}
+
+.scrutari-links-Poweredby {
+font-size: 0.8em;
+text-align: center;
+margin-top: 20px;
+}
+
+.scrutari-links-Title {
+margin-top: 20px;
+margin-bottom: 5px;
+word-wrap: break-word;
+font-weight: bold;
+}
+
+
+
+/*****************************************************
+* .scrutari-pagination
+******************************************************/
+
+.scrutari-pagination-List {
+margin-top: 15px;
+margin-bottom: 15px;
+}
+
+.scrutari-pagination-Tab, .scrutari-pagination-Current, .scrutari-pagination-Disabled {
+display: inline-block;
+padding-left: 4px;
+padding-right: 4px;
+}
+
+.scrutari-pagination-Tab {
+cursor: pointer;
+}
+
+.scrutari-pagination-Current, .scrutari-pagination-Tab:hover {
+background-color: #e9e9e9;
+}
+
+
+/*****************************************************
+* .scrutari-panel
+******************************************************/
+
+.scrutari-panel-Active {
+color: green;
+}
+
+.scrutari-panel-ColumnDisabled {
+opacity: 0.5;
+}
+
+.scrutari-panel-Excluded {
+text-decoration: line-through;
+color: grey;
+}
+
+.scrutari-panel-Icon {
+vertical-align: baseline;
+}
+
+
+/*****************************************************
+* .scrutari-stats
+******************************************************/
+
+.scrutari-stats-Table {
+ margin-bottom: 5px;
+}
+
+.scrutari-stats-Abbr {
+text-decoration: none;
+}
+
+.scrutari-stats-Count {
+font-family: monospace;
+font-weight: bold;
+text-align: right;
+}
+
+.scrutari-stats-Filter {
+color: green;
+}
+
+.scrutari-stats-None {
+color: red;
+}
+
+.scrutari-stats-Titles {
+font-size: 0.9em;
+padding-left: 10px;
+}
+
+.scrutari-stats-Cell {
+vertical-align: baseline;
+}
+
+.scrutari-stats-Number {
+text-align: right;
+padding-left: 10px;
+padding-right: 3px;
+}
+
+
+/*****************************************************
+* .scrutari-subsearch
+******************************************************/
+
+.scrutari-subsearch-Title {
+margin-top: 0;
+margin-bottom: 0;
+}
+.scrutari-subsearch-Form {
+margin-top: 0;
+margin-bottom: 25px;
+}
+
+
+/*****************************************************
+* .scrutari-title
+******************************************************/
+
+.scrutari-title-Main {
+font-size: 1.3em;
+margin-top: 20px;
+margin-bottom: 10px;
+}
\ No newline at end of file
diff --git a/squelettes/javascript/scrutarijs/scrutarijs.js b/squelettes/javascript/scrutarijs/scrutarijs.js
new file mode 100644
index 0000000..cb654dc
--- /dev/null
+++ b/squelettes/javascript/scrutarijs/scrutarijs.js
@@ -0,0 +1,2914 @@
+/* version: 1.3.2 */
+var Scrutari = {};
+Scrutari.log = function (msg) {
+ if ((console) && (console.log)) {
+ console.log(msg);
+ }
+};
+Scrutari.logError = function (error) {
+ var errorMessage = "Scrutari Request Error [key = " + error.key + " | parameter = " + error.parameter;
+ if (error.hasOwnProperty("value")) {
+ errorMessage += " | value = " + error.value;
+ }
+ if (error.hasOwnProperty("array")) {
+ errorMessage += " | array = (";
+ for(var i = 0; i < error.array.length; i++) {
+ if (i > 0) {
+ errorMessage += ";";
+ }
+ var obj = error.array[i];
+ errorMessage += obj.key;
+ if (obj.hasOwnProperty("value")) {
+ errorMessage += "=" + obj.value;
+ }
+ }
+ errorMessage += ")";
+ }
+ errorMessage += "}";
+ Scrutari.log(errorMessage);
+};
+Scrutari.convert = function (jqArgument) {
+ if (jqArgument.jquery) {
+ return jqArgument;
+ } else {
+ return $(jqArgument);
+ }
+};
+Scrutari.exists = function (jqArgument) {
+ return Scrutari.convert(jqArgument).length > 0;
+};
+ Scrutari.escape = function (text) {
+ var result = "";
+ for(var i = 0; i < text.length; i++) {
+ carac = text.charAt(i);
+ switch (carac) {
+ case '&':
+ result += "&";
+ break;
+ case '"':
+ result += """;
+ break;
+ case '<':
+ result += "<";
+ break;
+ case '>':
+ result += ">";
+ break;
+ case '\'':
+ result += "'";
+ break;
+ default:
+ result += carac;
+ }
+ }
+ return result;
+ };
+ Scrutari.$ = function (jqArgument, properties) {
+ if (!properties) {
+ properties = jqArgument;
+ jqArgument = null;
+ }
+ var query = Scrutari.toCssQuery(properties);
+ if (jqArgument) {
+ return Scrutari.convert(jqArgument).find(query);
+ } else {
+ return $(query);
+ }
+};
+Scrutari.$children = function (jqArgument, properties) {
+ return Scrutari.convert(jqArgument).children(Scrutari.toCssQuery(properties));
+};
+Scrutari.$parents = function (jqArgument, properties) {
+ return Scrutari.convert(jqArgument).parents(Scrutari.toCssQuery(properties));
+};
+Scrutari.toCssQuery = function (properties) {
+ var query = "";
+ var elementName = false;
+ var suffix = "";
+ for(let key in properties) {
+ let value = properties[key];
+ if (!key.startsWith("_")) {
+ if (value === true) {
+ query += "[" + Scrutari.toDataAttribute(key) + "]";
+ } else {
+ query += "[" + Scrutari.toDataAttribute(key) + "='" + value + "']";
+ }
+ } else if (key === "_checked") {
+ if (value) {
+ suffix += ":checked";
+ } else {
+ suffix += ":not(:checked)";
+ }
+ } else if (key === "_type") {
+ query += "[type='" + value + "']";
+ } else if (key === "_name") {
+ query += "[name='" + value + "']";
+ } else if (key === "_value") {
+ query += "[value='" + value + "']";
+ } else if (key === "_element") {
+ elementName = value;
+ }
+ }
+ if (elementName) {
+ query = elementName + query;
+ }
+ query += suffix;
+ return query;
+};
+Scrutari.toDataAttribute = function (camelCaseString) {
+ return "data-" + camelCaseString.replace(/[A-Z]/g, function (upperLetter) {
+ return "-" + upperLetter.toLowerCase();
+ });
+};
+Scrutari.Config = function (name, engineUrl, lang, origin, options) {
+ this.name = name;
+ this.engineUrl = engineUrl;
+ this.lang = lang;
+ this.origin = origin;
+ this.options = {
+ dataType: "json",
+ queryVariant: "query",
+ ficheFields: null,
+ motcleFields: null,
+ paginationLength: 50,
+ subsearchThreshold: 250,
+ groupSortFunction: _ficheCountSort
+ };
+ if (options) {
+ for(var key in options) {
+ this.options[key] = options[key];
+ }
+ }
+ function _ficheCountSort(group1, group2) {
+ let count1 = group1.ficheCount;
+ let count2 = group2.ficheCount;
+ if (count1 > count2) {
+ return -1;
+ } else if (count1 < count2) {
+ return 1;
+ } else {
+ let rank1 = group1.category.rank;
+ let rank2 = group1.category.rank;
+ if (rank1 < rank2) {
+ return -1;
+ } else if (rank1 > rank2) {
+ return 1;
+ } else {
+ return 0;
+ }
+ }
+ }
+};
+Scrutari.Config.prototype.getJsonUrl = function () {
+ return this.engineUrl + "json";
+};
+Scrutari.Config.prototype.getDownloadUrl = function (qId, extension) {
+ switch(extension) {
+ case "ods":
+ case "csv":
+ return this.engineUrl + "export/" + "result_" + qId + "_" + this.lang + "." + extension;
+ case "atom":
+ return this.engineUrl + "feed/" + "fiches_" + this.lang + ".atom?qid=" + qId + "&all=" + _getCurrentDate();
+ default:
+ Scrutari.log("Unknown extension: " + extension);
+ return "";
+ }
+ function _getCurrentDate() {
+ var date = new Date();
+ var dateString = date.getFullYear() + "-";
+ var mois = date.getMonth() + 1;
+ if (mois < 10) {
+ dateString += "0";
+ }
+ dateString += mois;
+ dateString += "-";
+ var jour = date.getDate();
+ if (jour < 10) {
+ dateString += "0";
+ }
+ dateString += jour;
+ return dateString;
+ }
+};
+Scrutari.Config.prototype.getPermalinkUrl = function (qId, permalinkPattern) {
+ var permalink = permalinkPattern.replace("$LANG", this.lang);
+ permalink = permalink.replace("$QID", qId);
+ return permalink;
+};
+Scrutari.Ajax = {};
+Scrutari.Ajax.loadBaseArray = function (scrutariConfig, requestParameters, baseArrayCallback) {
+ if (!requestParameters) {
+ requestParameters = new Object();
+ }
+ requestParameters.type = "base";
+ Scrutari.Ajax.check(requestParameters, "lang", scrutariConfig.lang);
+ Scrutari.Ajax.check(requestParameters, "warnings", 1);
+ Scrutari.Ajax.check(requestParameters, "version", 3);
+ $.ajax({
+ url: scrutariConfig.getJsonUrl(),
+ dataType: scrutariConfig.options.dataType,
+ data: requestParameters,
+ success: function (data, textStatus) {
+ Scrutari.Ajax.success(data, "baseArray", baseArrayCallback);
+ }
+ });
+};
+Scrutari.Ajax.loadCategoryArray = function (scrutariConfig, requestParameters, categoryArrayCallback) {
+ if (!requestParameters) {
+ requestParameters = new Object();
+ }
+ requestParameters.type = "category";
+ Scrutari.Ajax.check(requestParameters, "lang", scrutariConfig.lang);
+ Scrutari.Ajax.check(requestParameters, "warnings", 1);
+ Scrutari.Ajax.check(requestParameters, "version", 3);
+ $.ajax({
+ url: scrutariConfig.getJsonUrl(),
+ dataType: scrutariConfig.options.dataType,
+ data: requestParameters,
+ success: function (data, textStatus) {
+ Scrutari.Ajax.success(data, "categoryArray", categoryArrayCallback);
+ }
+ });
+};
+Scrutari.Ajax.loadCorpusArray = function (scrutariConfig, requestParameters, corpusArrayCallback) {
+ if (!requestParameters) {
+ requestParameters = new Object();
+ }
+ requestParameters.type = "corpus";
+ Scrutari.Ajax.check(requestParameters, "lang", scrutariConfig.lang);
+ Scrutari.Ajax.check(requestParameters, "warnings", 1);
+ Scrutari.Ajax.check(requestParameters, "version", 3);
+ $.ajax({
+ url: scrutariConfig.getJsonUrl(),
+ dataType: scrutariConfig.options.dataType,
+ data: requestParameters,
+ success: function (data, textStatus) {
+ Scrutari.Ajax.success(data, "corpusArray", corpusArrayCallback);
+ }
+ });
+};
+Scrutari.Ajax.loadEngineInfo = function (scrutariConfig, requestParameters, engineInfoCallback) {
+ if (!requestParameters) {
+ requestParameters = new Object();
+ }
+ requestParameters.type = "engine";
+ Scrutari.Ajax.check(requestParameters, "info", "all");
+ Scrutari.Ajax.check(requestParameters, "lang", scrutariConfig.lang);
+ Scrutari.Ajax.check(requestParameters, "warnings", 1);
+ Scrutari.Ajax.check(requestParameters, "version", 3);
+ $.ajax({
+ url: scrutariConfig.getJsonUrl(),
+ dataType: scrutariConfig.options.dataType,
+ data: requestParameters,
+ success: function (data, textStatus) {
+ Scrutari.Ajax.success(data, "engineInfo", engineInfoCallback);
+ }
+ });
+};
+Scrutari.Ajax.loadFicheArray = function (scrutariConfig, requestParameters, ficheArrayCallback) {
+ if (!requestParameters) {
+ requestParameters = new Object();
+ }
+ requestParameters.type = "fiche";
+ Scrutari.Ajax.check(requestParameters, "fieldvariant", "data");
+ Scrutari.Ajax.check(requestParameters, "lang", scrutariConfig.lang);
+ Scrutari.Ajax.check(requestParameters, "warnings", 1);
+ Scrutari.Ajax.check(requestParameters, "version", 3);
+ $.ajax({
+ url: scrutariConfig.getJsonUrl(),
+ dataType: scrutariConfig.options.dataType,
+ data: requestParameters,
+ success: function (data, textStatus) {
+ Scrutari.Ajax.success(data, ["ficheArray", "motcleArray"], ficheArrayCallback);
+ }
+ });
+};
+Scrutari.Ajax.loadGeoJson = function (scrutariConfig, requestParameters, geojsonCallback, apiErrorCallback) {
+ if (!requestParameters) {
+ requestParameters = new Object();
+ }
+ requestParameters.type = "geojson";
+ if ((scrutariConfig.options.ficheFields) || (scrutariConfig.options.motcleFields)) {
+ Scrutari.Ajax.check(requestParameters, "fichefields", scrutariConfig.options.ficheFields);
+ Scrutari.Ajax.check(requestParameters, "motclefields", scrutariConfig.options.motcleFields);
+ }
+ Scrutari.Ajax.check(requestParameters, "lang", scrutariConfig.lang);
+ Scrutari.Ajax.check(requestParameters, "fieldvariant", scrutariConfig.options.queryVariant);
+ Scrutari.Ajax.check(requestParameters, "origin", scrutariConfig.origin);
+ Scrutari.Ajax.check(requestParameters, "warnings", 1);
+ Scrutari.Ajax.check(requestParameters, "version", 3);
+ $.ajax({
+ url: scrutariConfig.getJsonUrl(),
+ dataType: scrutariConfig.options.dataType,
+ data: requestParameters,
+ success: function (data, textStatus) {
+ if (data.hasOwnProperty("error")) {
+ if (apiErrorCallback) {
+ apiErrorCallback(data.error);
+ } else {
+ Scrutari.logError(data.error);
+ }
+ } else {
+ Scrutari.Ajax.logWarnings(data);
+ geojsonCallback(data);
+ }
+ }
+ });
+};
+Scrutari.Ajax.loadMotcleArray = function (scrutariConfig, requestParameters, motcleArrayCallback) {
+ if (!requestParameters) {
+ requestParameters = new Object();
+ }
+ requestParameters.type = "motcle";
+ Scrutari.Ajax.check(requestParameters, "fieldvariant", "data");
+ Scrutari.Ajax.check(requestParameters, "lang", scrutariConfig.lang);
+ Scrutari.Ajax.check(requestParameters, "warnings", 1);
+ Scrutari.Ajax.check(requestParameters, "version", 3);
+ $.ajax({
+ url: scrutariConfig.getJsonUrl(),
+ dataType: scrutariConfig.options.dataType,
+ data: requestParameters,
+ success: function (data, textStatus) {
+ Scrutari.Ajax.success(data, "motcleArray", motcleArrayCallback);
+ }
+ });
+};
+Scrutari.Ajax.loadThesaurusArray = function (scrutariConfig, requestParameters, thesaurusArrayCallback) {
+ if (!requestParameters) {
+ requestParameters = new Object();
+ }
+ requestParameters.type = "thesaurus";
+ Scrutari.Ajax.check(requestParameters, "lang", scrutariConfig.lang);
+ Scrutari.Ajax.check(requestParameters, "warnings", 1);
+ Scrutari.Ajax.check(requestParameters, "version", 3);
+ $.ajax({
+ url: scrutariConfig.getJsonUrl(),
+ dataType: scrutariConfig.options.dataType,
+ data: requestParameters,
+ success: function (data, textStatus) {
+ Scrutari.Ajax.success(data, "thesaurusArray", thesaurusArrayCallback);
+ }
+ });
+};
+Scrutari.Ajax.loadFicheSearchResult = function (scrutariConfig, requestParameters, ficheSearchResultCallback, apiErrorCallback) {
+ if (!requestParameters) {
+ requestParameters = new Object();
+ }
+ requestParameters.type = "q-fiche";
+ if (scrutariConfig.options.ficheFields !== null) {
+ Scrutari.Ajax.check(requestParameters, "fichefields", scrutariConfig.options.ficheFields);
+ }
+ if (scrutariConfig.options.motcleFields !== null) {
+ Scrutari.Ajax.check(requestParameters, "motclefields", scrutariConfig.options.motcleFields);
+ }
+ Scrutari.Ajax.check(requestParameters, "lang", scrutariConfig.lang);
+ Scrutari.Ajax.check(requestParameters, "fieldvariant", scrutariConfig.options.queryVariant);
+ Scrutari.Ajax.check(requestParameters, "q-mode", "intersection");
+ Scrutari.Ajax.check(requestParameters, "origin", scrutariConfig.origin);
+ Scrutari.Ajax.check(requestParameters, "warnings", 1);
+ Scrutari.Ajax.check(requestParameters, "version", 3);
+ Scrutari.Ajax.check(requestParameters, "start", 1);
+ Scrutari.Ajax.check(requestParameters, "limit", scrutariConfig.options.paginationLength * 2);
+ Scrutari.Ajax.check(requestParameters, "starttype", "in_all");
+ $.ajax({
+ url: scrutariConfig.getJsonUrl(),
+ dataType: scrutariConfig.options.dataType,
+ data: requestParameters,
+ success: function (data, textStatus) {
+ Scrutari.Ajax.success(data, "ficheSearchResult", ficheSearchResultCallback, apiErrorCallback);
+ }
+ });
+};
+Scrutari.Ajax.loadExistingFicheSearchResult = function (scrutariConfig, requestParameters, existingFicheSearchResultCallback) {
+ if (!requestParameters) {
+ requestParameters = new Object();
+ }
+ requestParameters.type = "q-fiche";
+ if ((scrutariConfig.options.ficheFields) || (scrutariConfig.options.motcleFields)) {
+ Scrutari.Ajax.check(requestParameters, "fichefields", scrutariConfig.options.ficheFields);
+ Scrutari.Ajax.check(requestParameters, "motclefields", scrutariConfig.options.motcleFields);
+ }
+ Scrutari.Ajax.check(requestParameters, "lang", scrutariConfig.lang);
+ Scrutari.Ajax.check(requestParameters, "fieldvariant", scrutariConfig.options.queryVariant);
+ Scrutari.Ajax.check(requestParameters, "insert", "-searchmeta,-motclearray");
+ Scrutari.Ajax.check(requestParameters, "warnings", 1);
+ Scrutari.Ajax.check(requestParameters, "version", 3);
+ Scrutari.Ajax.check(requestParameters, "start", 1);
+ Scrutari.Ajax.check(requestParameters, "limit", scrutariConfig.options.paginationLength * 2);
+ $.ajax({
+ url: scrutariConfig.getJsonUrl(),
+ dataType: scrutariConfig.options.dataType,
+ data: requestParameters,
+ success: function (data, textStatus) {
+ Scrutari.Ajax.success(data, "ficheSearchResult", existingFicheSearchResultCallback);
+ }
+ });
+};
+Scrutari.Ajax.success = function(ajaxResult, objectNames, objectCallback, apiErrorCallback) {
+ if (ajaxResult.hasOwnProperty("error")) {
+ if (apiErrorCallback) {
+ apiErrorCallback(ajaxResult.error);
+ } else {
+ Scrutari.logError(ajaxResult.error);
+ }
+ } else {
+ Scrutari.Ajax.logWarnings(ajaxResult);
+ if (Array.isArray(objectNames)) {
+ let apiObjectArray = new Array();
+ for(let objectName of objectNames) {
+ if (!ajaxResult.hasOwnProperty(objectName)) {
+ apiObjectArray.push(null);
+ } else {
+ apiObjectArray.push(ajaxResult[objectName]);
+ }
+ }
+ objectCallback.apply(this, apiObjectArray);
+ } else {
+ let objectName = objectNames;
+ if (!ajaxResult.hasOwnProperty(objectName)) {
+ $.error(objectName + " object is missing in json response");
+ } else {
+ objectCallback(ajaxResult[objectName]);
+ }
+ }
+ }
+};
+Scrutari.Ajax.logWarnings = function (ajaxResult) {
+ if (ajaxResult.hasOwnProperty("warnings")) {
+ var warningsMessage = "Scrutari Request Warnings [";
+ for(var i = 0; i < ajaxResult.warnings.length; i++) {
+ if (i > 0) {
+ warningsMessage += ";";
+ }
+ var warning = ajaxResult.warnings[i];
+ warningsMessage += "key = ";
+ warningsMessage += warning.key;
+ warningsMessage += " | parameter = ";
+ warningsMessage += warning.parameter;
+ if (warning.hasOwnProperty("value")) {
+ warningsMessage += " | value = ";
+ warningsMessage += warning.value;
+ }
+ }
+ warningsMessage += "]";
+ Scrutari.log(warningsMessage);
+ }
+};
+Scrutari.Ajax.check = function (obj, name, defaultValue) {
+ if (!obj.hasOwnProperty(name)) {
+ if (defaultValue) {
+ obj[name] = defaultValue;
+ } else {
+ obj[name] = "";
+ }
+ }
+};
+Scrutari.Meta = function (engineInfo) {
+ this.engineInfo = engineInfo;
+};
+Scrutari.Meta.load = function(scrutariConfig, callback) {
+ Scrutari.Ajax.loadEngineInfo(scrutariConfig, null, function (engineInfo) {
+ let scrutariMeta = new Scrutari.Meta(engineInfo);
+ if (callback) {
+ callback(scrutariMeta);
+ }
+ });
+};
+Scrutari.Meta.prototype.getAttributeArray = function (familyName) {
+ if (!this.engineInfo.hasOwnProperty("attributes")) {
+ return new Array();
+ }
+ if (!this.engineInfo.attributes.hasOwnProperty(familyName)) {
+ return new Array();
+ }
+ return this.engineInfo.attributes[familyName];
+};
+Scrutari.Meta.prototype.getBase = function (code) {
+ var key = "code_" + code;
+ if (this.engineInfo.baseMap.hasOwnProperty(key)) {
+ return this.engineInfo.baseMap[key];
+ } else {
+ return null;
+ }
+};
+Scrutari.Meta.prototype.getBaseArray = function (sortFunction) {
+ var array = new Array();
+ var baseMap = this.engineInfo.baseMap;
+ var p=0;
+ for(let prop in baseMap) {
+ array[p] = baseMap[prop];
+ p++;
+ }
+ if (sortFunction) {
+ array = array.sort(sortFunction);
+ }
+ return array;
+};
+Scrutari.Meta.prototype.getCategory = function (categoryName) {
+ if (this.engineInfo.hasOwnProperty("categoryMap")) {
+ if (this.engineInfo.categoryMap.hasOwnProperty(categoryName)) {
+ return this.engineInfo.categoryMap[categoryName];
+ } else {
+ return null;
+ }
+ } else {
+ return null;
+ }
+};
+Scrutari.Meta.prototype.getCategoryArray = function (sortFunction) {
+ var array = new Array();
+ if (!this.engineInfo.hasOwnProperty("categoryMap")) {
+ return array;
+ }
+ var categoryMap = this.engineInfo.categoryMap;
+ var p=0;
+ for(let prop in categoryMap) {
+ array[p] = categoryMap[prop];
+ p++;
+ }
+ if (sortFunction) {
+ array = array.sort(sortFunction);
+ }
+ return array;
+};
+Scrutari.Meta.prototype.getCategoryForCorpus = function (code) {
+ if (!this.engineInfo.hasOwnProperty("categoryMap")) {
+ return null;
+ }
+ var categoryMap = this.engineInfo.categoryMap;
+ for(let prop in categoryMap) {
+ let category = categoryMap[prop];
+ for(let codecorpus of category.codecorpusArray) {
+ if (codecorpus === code) {
+ return category;
+ }
+ }
+ }
+ return null;
+ };
+Scrutari.Meta.prototype.getComplementTitle = function(code, complementNumber) {
+ var corpus = this.getCorpus(code);
+ if (!corpus) {
+ return "";
+ }
+ var key = "complement_" + complementNumber;
+ if (corpus.phraseMap.hasOwnProperty(key)) {
+ return corpus.phraseMap[key];
+ } else {
+ return key;
+ }
+};
+Scrutari.Meta.prototype.getCorpus = function (code) {
+ var key = "code_" + code;
+ if (this.engineInfo.corpusMap.hasOwnProperty(key)) {
+ return this.engineInfo.corpusMap[key];
+ } else {
+ return null;
+ }
+};
+Scrutari.Meta.prototype.getCorpusArray = function (sortFunction) {
+ var array = new Array();
+ var corpusMap = this.engineInfo.corpusMap;
+ var p=0;
+ for(let prop in corpusMap) {
+ array[p] = corpusMap[prop];
+ p++;
+ }
+ if (sortFunction) {
+ array = array.sort(sortFunction);
+ }
+ return array;
+};
+Scrutari.Meta.prototype.getCorpusArrayForBases = function (baseArray) {
+ var result = new Array();
+ for(let codebase of baseArray) {
+ let key = "code_" +codebase;
+ if (this.engineInfo.baseMap.hasOwnProperty(key)) {
+ result = result.concat(this.engineInfo.baseMap[key].codecorpusArray);
+ }
+ }
+ return result;
+};
+Scrutari.Meta.prototype.getCorpusArrayForCategories = function (categoryArray) {
+ var result = new Array();
+ if (!this.engineInfo.hasOwnProperty("categoryMap")) {
+ return result;
+ }
+ for(let categoryName of categoryArray) {
+ if (this.engineInfo.categoryMap.hasOwnProperty(categoryName)) {
+ result = result.concat(this.engineInfo.categoryMap[categoryName].codecorpusArray);
+ }
+ }
+ return result;
+};
+Scrutari.Meta.prototype.getCorpusFicheCount = function (code) {
+ var corpus = this.getCorpus(code);
+ if (!corpus) {
+ return 0;
+ }
+ return corpus.stats.fiche;
+};
+Scrutari.Meta.prototype.getCorpusLangFicheCount = function (code, langArray) {
+ var corpus = this.getCorpus(code);
+ if (!corpus) {
+ return 0;
+ }
+ var ficheCount = 0;
+ for(let langObj of corpus.stats.langArray) {
+ if ($.inArray(langObj.lang, langArray) !== -1) {
+ ficheCount += langObj.fiche;
+ }
+ }
+ return ficheCount;
+};
+Scrutari.Meta.prototype.getDefaultOptions = function () {
+ var options = {};
+ var attrMap = this.engineInfo.metadata.attrMap;
+ for(let key in attrMap) {
+ if (key.indexOf("scrutarijs:") === 0) {
+ let name = key.substring("scrutarijs:".length);
+ let values = attrMap[key];
+ if (values.length === 1) {
+ let value = values[0];
+ if (value === "false") {
+ value = false;
+ } else if (value === "true") {
+ value = true;
+ }
+ options[name] = value;
+ } else {
+ options[name] = values;
+ }
+ }
+ this[key] = options[key];
+ }
+ return options;
+};
+Scrutari.Meta.prototype.getEngineInfo = function () {
+ return this.engineInfo;
+};
+Scrutari.Meta.prototype.getGlobalFicheCount = function () {
+ return this.engineInfo.stats.fiche;
+};
+Scrutari.Meta.prototype.getGlobalLangFicheCount = function (langArray) {
+ var ficheCount = 0;
+ for(let langObj of this.engineInfo.stats.langArray) {
+ if ($.inArray(langObj.lang, langArray) !== -1) {
+ ficheCount += langObj.fiche;
+ }
+ }
+ return ficheCount;
+};
+Scrutari.Meta.prototype.getLangArray = function (sortFunction) {
+ var array = new Array();
+ var length = this.engineInfo.stats.langArray.length;
+ for(let i = 0; i < length; i++) {
+ array[i] = this.engineInfo.stats.langArray[i];
+ }
+ if (sortFunction) {
+ array = array.sort(sortFunction);
+ }
+ return array;
+};
+Scrutari.Meta.prototype.getLangLabel = function (iso) {
+ if (this.engineInfo.langMap.hasOwnProperty(iso)) {
+ return this.engineInfo.langMap[iso];
+ } else {
+ return iso;
+ }
+};
+Scrutari.Meta.prototype.getThesaurus = function (code) {
+ var key = "code_" + code;
+ if (this.engineInfo.thesaurusMap.hasOwnProperty(key)) {
+ return this.engineInfo.thesaurusMap[key];
+ } else {
+ return null;
+ }
+};
+Scrutari.Meta.prototype.getThesaurusArray = function (sortFunction) {
+ var array = new Array();
+ var thesaurusMap = this.engineInfo.thesaurusMap;
+ var p=0;
+ for(let prop in thesaurusMap) {
+ array[p] = thesaurusMap[prop];
+ p++;
+ }
+ if (sortFunction) {
+ array = array.sort(sortFunction);
+ }
+ return array;
+};
+Scrutari.Meta.prototype.getTitle = function () {
+ return this.engineInfo.metadata.title;
+};
+Scrutari.Meta.prototype.withCategory = function () {
+ return this.engineInfo.hasOwnProperty("categoryMap");
+};
+Scrutari.Complete = {};
+Scrutari.Complete.bythesaurusArray = function (fiche, scrutariMeta, motcleProvider) {
+ if (!fiche.hasOwnProperty("bythesaurusMap")) {
+ return false;
+ }
+ let thesaurusArray = scrutariMeta.getThesaurusArray();
+ let _bythesaurusArray = new Array();
+ for(let thesaurus of thesaurusArray) {
+ let codethesaurus = thesaurus.codethesaurus;
+ let key = "code_" + codethesaurus;
+ if (fiche.bythesaurusMap.hasOwnProperty(key)) {
+ let motcleArray = new Array();
+ for(let codemotcle of fiche.bythesaurusMap[key]) {
+ let motcle = motcleProvider(codemotcle);
+ if (motcle) {
+ motcleArray.push(motcle);
+ }
+ }
+ _bythesaurusArray.push({
+ thesaurus: thesaurus,
+ motcleArray: motcleArray
+ });
+ }
+ }
+ fiche._bythesaurusArray = _bythesaurusArray;
+ return true;
+};
+Scrutari.Complete.complementTitle = function (fiche, scrutariMeta) {
+ if (fiche.hasOwnProperty("mcomplementArray")) {
+ for(let mcomplement of fiche.mcomplementArray) {
+ mcomplement.title = scrutariMeta.getComplementTitle(fiche.codecorpus, mcomplement.number);
+ }
+ return true;
+ } else {
+ return false;
+ }
+};
+Scrutari.Complete.icon = function (fiche) {
+ if (fiche.hasOwnProperty("icon")) {
+ fiche._icon = fiche.icon;
+ return true;
+ } else if (fiche.hasOwnProperty("ficheicon")) {
+ fiche._icon = fiche.ficheicon;
+ return true;
+ } else {
+ return false;
+ }
+};
+Scrutari.Complete.markedAttributeArray = function (fiche, scrutariMeta, familyName ) {
+ let attributeArray = scrutariMeta.getAttributeArray(familyName);
+ if (attributeArray.length === 0) {
+ return false;
+ }
+ let objArray = new Array();
+ for(let attribute of attributeArray) {
+ if (fiche.mattrMap.hasOwnProperty(attribute.name)) {
+ objArray.push({
+ name: attribute.name,
+ title: attribute.title,
+ type: attribute.type,
+ valueArray: fiche.mattrMap[attribute.name]
+ });
+ }
+ }
+ fiche["_" + familyName + "AttributeArray"] = objArray;
+ return true;
+};
+Scrutari.Complete.motcleArray = function (fiche, motcleProvider) {
+ if (!fiche.hasOwnProperty("codemotcleArray")) {
+ return false;
+ }
+ let motcleArray = new Array();
+ for(let codemotcle of fiche.codemotcleArray) {
+ let motcle = motcleProvider(codemotcle);
+ if (motcle) {
+ motcleArray.push(motcle);
+ }
+ }
+ if (motcleArray.length > 0) {
+ fiche._motcleArray = motcleArray;
+ return true;
+ } else {
+ return false;
+ }
+};
+Scrutari.Complete.target = function (fiche, target) {
+ fiche._target = target;
+ return true;
+};
+Scrutari.Complete.thumbnail = function (fiche) {
+ if (fiche.hasOwnProperty("thumbnail")) {
+ fiche._thumbnail = fiche.thumbnail;
+ return true;
+ } else if (Scrutari.Complete.hasAttribute(fiche, "sct:thumbnail")) {
+ fiche._thumbnail = fiche.attrMap["sct:thumbnail"][0];
+ return true;
+ } else {
+ return false;
+ }
+};
+Scrutari.Complete.hasAttribute = function (fiche, attributeKey) {
+ if (!fiche.attrMap) {
+ return false;
+ }
+ if (attributeKey) {
+ return fiche.attrMap.hasOwnProperty(attributeKey);
+ } else {
+ return true;
+ }
+};
+Scrutari.Complete.hasMarkedAttribute = function (fiche, attributeKey) {
+ if (!fiche.mattrMap) {
+ return false;
+ }
+ if (attributeKey) {
+ return fiche.mattrMap.hasOwnProperty(attributeKey);
+ } else {
+ return true;
+ }
+};
+Scrutari.Result = function (ficheSearchResult, requestParameters, groupSortFunction) {
+ this.ficheSearchResult = ficheSearchResult;
+ this.requestParameters = requestParameters;
+ this.searchMeta = ficheSearchResult.searchMeta;
+ this.ficheGroupArray = ficheSearchResult.ficheGroupArray;
+ if ((groupSortFunction) && (this.ficheGroupArray.length > 1)) {
+ this.ficheGroupArray = this.ficheGroupArray.sort(groupSortFunction);
+ }
+ this.motcleMap = new Object();
+ if (ficheSearchResult.hasOwnProperty("motcleArray")) {
+ for(let motcle of ficheSearchResult.motcleArray) {
+ this.motcleMap["code_" + motcle.codemotcle] = motcle;
+ }
+ }
+};
+Scrutari.Result.newSearch = function (scrutariConfig, requestParameters, callback, apiErrorCallback) {
+ Scrutari.Ajax.loadFicheSearchResult(scrutariConfig, requestParameters, _ficheSearchResultCallback, apiErrorCallback);
+ function _ficheSearchResultCallback(ficheSearchResult) {
+ callback(new Scrutari.Result(ficheSearchResult, requestParameters, scrutariConfig.options.groupSortFunction));
+ }
+};
+Scrutari.Result.prototype.getQId = function () {
+ if (this.searchMeta) {
+ return this.searchMeta.qId;
+ } else {
+ return "";
+ }
+};
+Scrutari.Result.prototype.getQ = function () {
+ if (this.searchMeta) {
+ return this.searchMeta.q;
+ } else {
+ return "";
+ }
+};
+Scrutari.Result.prototype.getFicheCount = function () {
+ if (this.searchMeta) {
+ return this.searchMeta.ficheCount;
+ } else {
+ return -1;
+ }
+};
+Scrutari.Result.prototype.getFicheGroupType = function () {
+ var type = this.ficheSearchResult.ficheGroupType;
+ if (type === "none") {
+ type = "unique";
+ }
+ return type;
+};
+Scrutari.Result.prototype.getUniqueFicheArray = function () {
+ if (this.ficheGroupArray.length === 0) {
+ return new Array();
+ }
+ return this.ficheGroupArray[0].ficheArray;
+};
+Scrutari.Result.prototype.selectUniqueFicheArray = function (paginationLength, paginationNumber) {
+ var selectionArray = new Array();
+ if (this.ficheGroupArray.length === 0) {
+ return selectionArray;
+ }
+ var ficheArray = this.ficheGroupArray[0].ficheArray;
+ var startIndex = paginationLength * (paginationNumber - 1);
+ var length = ficheArray.length;
+ if (startIndex >= length) {
+ return selectionArray;
+ }
+ var min = Math.min(ficheArray.length, startIndex + paginationLength);
+ for(let i = startIndex; i < min; i++) {
+ selectionArray.push(ficheArray[i]);
+ }
+ return selectionArray;
+};
+Scrutari.Result.prototype.isUniquePaginationLoaded = function (paginationLength, paginationNumber) {
+ if (this.ficheGroupArray.length === 0) {
+ return true;
+ }
+ var ficheCount = this.getFicheCount();
+ var ficheArray = this.ficheGroupArray[0].ficheArray;
+ var length = ficheArray.length;
+ if (length === ficheCount) {
+ return true;
+ }
+ var endIndex = (paginationLength * paginationNumber) - 1;
+ if (endIndex < length) {
+ return true;
+ }
+ return false;
+};
+Scrutari.Result.prototype.loadUniquePagination = function (scrutariConfig, paginationLength, paginationNumber, callback) {
+ if (this.ficheGroupArray.length === 0) {
+ return true;
+ }
+ var group = this.ficheGroupArray[0];
+ if (!group) {
+ return;
+ }
+ var ficheCount = this.getFicheCount();
+ var ficheArray = group.ficheArray;
+ var length = ficheArray.length;
+ if (length === ficheCount) {
+ return;
+ }
+ var _existingFicheSearchResultCallback = function (ficheSearchResult) {
+ var newCount = ficheSearchResult.ficheGroupArray.length;
+ if (newCount > 0) {
+ group.ficheArray = group.ficheArray.concat(ficheSearchResult.ficheGroupArray[0].ficheArray);
+ }
+ if (callback) {
+ callback();
+ }
+ };
+ var requestParameters = {
+ qid: this.getQId(),
+ start: length +1,
+ limit: (paginationLength * (paginationNumber + 2)) - length
+ };
+ Scrutari.Ajax.loadExistingFicheSearchResult(scrutariConfig, requestParameters, _existingFicheSearchResultCallback);
+};
+Scrutari.Result.prototype.isCategoryPaginationLoaded = function (categoryName, paginationLength, paginationNumber) {
+ var group = this.getFicheGroupByCategoryName(categoryName);
+ if (!group) {
+ return true;
+ }
+ var categoryFicheCount = group.ficheCount;
+ var ficheArray = group.ficheArray;
+ var length = ficheArray.length;
+ if (length === categoryFicheCount) {
+ return true;
+ }
+ var endIndex = (paginationLength * paginationNumber) - 1;
+ if (endIndex < length) {
+ return true;
+ }
+ return false;
+};
+Scrutari.Result.prototype.loadCategoryPagination = function (scrutariConfig, categoryName, paginationLength, paginationNumber, callback) {
+ var group = this.getFicheGroupByCategoryName(categoryName);
+ if (!group) {
+ return;
+ }
+ var categoryFicheCount = group.ficheCount;
+ var ficheArray = group.ficheArray;
+ var length = ficheArray.length;
+ if (length === categoryFicheCount) {
+ return;
+ }
+ var requestParameters = {
+ qid: this.getQId(),
+ start: length +1,
+ limit: (paginationLength * (paginationNumber + 2)) - length,
+ starttype: "in:" + categoryName
+ };
+ Scrutari.Ajax.loadExistingFicheSearchResult(scrutariConfig, requestParameters, _existingFicheSearchResultCallback);
+ function _existingFicheSearchResultCallback(ficheSearchResult) {
+ for(let newGroup of ficheSearchResult.ficheGroupArray) {
+ if (newGroup.category.name === group.category.name) {
+ group.ficheArray = group.ficheArray.concat(newGroup.ficheArray);
+ }
+ }
+ callback();
+ }
+};
+Scrutari.Result.prototype.selectCategoryFicheArray = function (categoryName, paginationLength, paginationNumber) {
+ var selectionArray = new Array();
+ var ficheArray = this.getCategoryFicheArrayByName(categoryName);
+ var startIndex = paginationLength * (paginationNumber - 1);
+ var length = ficheArray.length;
+ if (startIndex >= length) {
+ return selectionArray;
+ }
+ var min = Math.min(ficheArray.length, startIndex + paginationLength);
+ for(let i = startIndex; i < min; i++) {
+ selectionArray.push(ficheArray[i]);
+ }
+ return selectionArray;
+};
+Scrutari.Result.prototype.getCategoryCount = function () {
+ return this.ficheGroupArray.length;
+};
+Scrutari.Result.prototype.getCategory = function (index) {
+ return this.ficheGroupArray[index].category;
+};
+Scrutari.Result.prototype.getFicheGroupByCategoryName = function (categoryName) {
+ var groupCount = this.ficheGroupArray.length;
+ for(let i = 0; i < groupCount; i++) {
+ let group = this.ficheGroupArray[i];
+ if ((group.category) && (group.category.name === categoryName)) {
+ return group;
+ }
+ }
+ return null;
+};
+Scrutari.Result.prototype.getCategoryFicheCount = function (index) {
+ return this.ficheGroupArray[index].ficheCount;
+};
+Scrutari.Result.prototype.getCategoryFicheCountByName = function (categoryName) {
+ for(let group of this.ficheGroupArray) {
+ if ((group.category) && (group.category.name === categoryName)) {
+ return group.ficheCount;
+ }
+ }
+ return 0;
+};
+Scrutari.Result.prototype.getCategoryFicheArray = function (index) {
+ return this.ficheGroupArray[index].ficheArray;
+};
+Scrutari.Result.prototype.getCategoryFicheArrayByName = function (categoryName) {
+ var categoryCount = this.getCategoryCount();
+ for(let i = 0; i < categoryCount; i++) {
+ let category = this.getCategory(i);
+ if (category.name === categoryName) {
+ return this.getCategoryFicheArray(i);
+ }
+ }
+ return new Array();
+};
+Scrutari.Result.prototype.getMotcle = function (code) {
+ var key = "code_" + code;
+ if (this.motcleMap.hasOwnProperty(key)) {
+ return this.motcleMap[key];
+ } else {
+ return null;
+ }
+};
+Scrutari.Result.prototype.getMotcleArray = function (motcleFilter) {
+ if (!motcleFilter) {
+ motcleFilter = _accept;
+ }
+ var result = new Array();
+ if (this.ficheSearchResult.hasOwnProperty("motcleArray")) {
+ for(let motcle of this.ficheSearchResult.motcleArray) {
+ if (motcleFilter(motcle)) {
+ result.push(motcle);
+ }
+ }
+ }
+ return result;
+ function _accept(motcle) {
+ return true;
+ }
+};
+Scrutari.Utils = {};
+Scrutari.Utils.divideIntoColumns = function (objectArray, jqArgument, objectTemplate) {
+ var objectCount = objectArray.length;
+ if (objectCount === 0) {
+ return;
+ }
+ var $elements = Scrutari.convert(jqArgument);
+ var elementCount = $elements.length;
+ if (elementCount === 0) {
+ Scrutari.log("HtmlElement selection with jqArgument is empty ");
+ return;
+ }
+ var objectCount = objectArray.length;
+ if (objectCount <= elementCount) {
+ for(var i = 0; i < objectCount; i++) {
+ $($elements[i]).append(objectTemplate(objectArray[i]));
+ }
+ return;
+ }
+ var modulo = objectCount % elementCount;
+ var columnLength = (objectCount - modulo) / elementCount;
+ var start = 0;
+ var stop = 0;
+ for(var i = 0; i< elementCount; i++) {
+ var $element = $($elements[i]);
+ stop += columnLength;
+ if (i < modulo) {
+ stop++;
+ }
+ for(var j = start; j < stop; j++) {
+ $element.append(objectTemplate(objectArray[j]));
+ }
+ start = stop;
+ }
+};
+Scrutari.Utils.getTabArray = function (ficheCount, paginationLength, currentPaginationNumber) {
+ var result = new Array();
+ var paginationCount;
+ if (ficheCount <= paginationLength) {
+ paginationCount = 1;
+ return result;
+ } else {
+ var modulo = ficheCount % paginationLength;
+ paginationCount = (ficheCount - modulo) / paginationLength;
+ if (modulo > 0) {
+ paginationCount ++;
+ }
+ }
+ if (currentPaginationNumber > paginationCount) {
+ currentPaginationNumber = paginationCount;
+ }
+ var paginationNumberStart = 1;
+ var paginationNumberEnd = 9;
+ if (currentPaginationNumber > 6) {
+ paginationNumberStart = currentPaginationNumber - 3;
+ paginationNumberEnd = currentPaginationNumber + 3;
+ }
+ if (paginationNumberEnd > paginationCount) {
+ paginationNumberEnd = paginationCount;
+ }
+ if (paginationNumberStart > 1) {
+ result.push({
+ number: 1,
+ title: "1",
+ state: 'enabled'
+ });
+ result.push({
+ number: 0,
+ title: "…",
+ state: 'disabled'
+ });
+ }
+ for(var i = paginationNumberStart; i <= paginationNumberEnd; i++) {
+ var state = 'enabled';
+ if (i === currentPaginationNumber) {
+ state = 'active';
+ }
+ result.push({
+ number: i,
+ title: i.toString(),
+ state: state
+ });
+ }
+ if (paginationNumberEnd < paginationCount) {
+ result.push({
+ number: 0,
+ title: "…",
+ state: 'disabled'
+ });
+ }
+ return result;
+};
+Scrutari.Utils.disable = function (jqArgument) {
+ var $elements = Scrutari.convert(jqArgument);
+ $elements.prop('disabled', true);
+ return $elements;
+};
+Scrutari.Utils.enable = function (jqArgument) {
+ var $elements = Scrutari.convert(jqArgument);
+ $elements.prop('disabled', false);
+ return $elements;
+};
+Scrutari.Utils.uncheck = function (jqArgument) {
+ var $elements = Scrutari.convert(jqArgument);
+ $elements.prop('checked', false);
+ return $elements;
+};
+Scrutari.Utils.check = function (jqArgument) {
+ var $elements = Scrutari.convert(jqArgument);
+ $elements.prop('checked', true);
+ return $elements;
+};
+Scrutari.Utils.toggle = function (jqElement, stateDataKey) {
+ var state = jqElement.data(stateDataKey);
+ if (state === 'off') {
+ state = 'on';
+ } else {
+ state = 'off';
+ }
+ jqElement.data(stateDataKey, state);
+ return state;
+};
+Scrutari.Utils.toggle.disabled = function (jqArgument, state) {
+ var $elements = Scrutari.convert(jqArgument);
+ if (state === 'off') {
+ $elements.prop('disabled', true);
+ } else {
+ $elements.prop('disabled', false);
+ }
+ return $elements;
+};
+Scrutari.Utils.toggle.text = function (jqArgument, alterDataKey) {
+ var $elements = Scrutari.convert(jqArgument);
+ var length = $elements.length;
+ for(var i = 0; i < length; i++) {
+ var jqEl = $($elements[i]);
+ var currentText =jqEl.text();
+ var alterText = jqEl.data(alterDataKey);
+ jqEl.text(alterText);
+ jqEl.data(alterDataKey, currentText);
+ }
+ return $elements;
+};
+Scrutari.Utils.toggle.classes = function (jqArgument, state, onClass, offClass) {
+ var $elements = Scrutari.convert(jqArgument);
+ if (state === 'off') {
+ $elements.addClass(offClass).removeClass(onClass);
+ } else {
+ $elements.removeClass(offClass).addClass(onClass);
+ }
+ return $elements;
+};
+Scrutari.Utils.getBaseSortFunction = function (baseSortType, locales) {
+ var compareFunction = Scrutari.Utils.getCompareLocaleFunction(locales);
+ switch(baseSortType) {
+ case "fiche-count":
+ return _ficheCountSort;
+ case "title":
+ return _titleSort;
+ default:
+ return null;
+ }
+ function _ficheCountSort(base1, base2) {
+ var count1 = base1.stats.fiche;
+ var count2 = base2.stats.fiche;
+ if (count1 > count2) {
+ return -1;
+ } else if (count1 < count2) {
+ return 1;
+ } else {
+ return Scrutari.Utils.compareCodebase(base1, base2);
+ }
+ }
+ function _titleSort(base1, base2) {
+ var title1 = base1.title;
+ var title2 = base2.title;
+ if (!title1) {
+ title1 = "";
+ }
+ if (!title2) {
+ title2 = "";
+ }
+ var comp = compareFunction(title1, title2);
+ if (comp !== 0) {
+ return comp;
+ } else {
+ return Scrutari.Utils.compareCodebase(base1, base2);
+ }
+ }
+};
+Scrutari.Utils.getCorpusSortFunction = function (corpusSortType, locales) {
+ var _ficheCountSort = function (corpus1, corpus2) {
+ var count1 = corpus1.stats.fiche;
+ var count2 = corpus2.stats.fiche;
+ if (count1 > count2) {
+ return -1;
+ } else if (count1 < count2) {
+ return 1;
+ } else {
+ return Scrutari.Utils.compareCodecorpus(corpus1, corpus2);
+ }
+ };
+ var compareFunction = Scrutari.Utils.getCompareLocaleFunction(locales);
+ var _titleSort = function (corpus1, corpus2) {
+ var title1 = corpus1.title;
+ var title2 = corpus2.title;
+ if (!title1) {
+ title1 = "";
+ }
+ if (!title2) {
+ title2 = "";
+ }
+ var comp = compareFunction(title1, title2);
+ if (comp !== 0) {
+ return comp;
+ } else {
+ return Scrutari.Utils.compareCodecorpus(corpus1, corpus2);
+ }
+ };
+ switch(corpusSortType) {
+ case "fiche-count":
+ return _ficheCountSort;
+ case "title":
+ return _titleSort;
+ default:
+ return null;
+ }
+};
+Scrutari.Utils.getCategorySortFunction = function (categorySortType, locales) {
+ var compareFunction = Scrutari.Utils.getCompareLocaleFunction(locales);
+ switch(categorySortType) {
+ case "rank":
+ return _rankSort;
+ case "fiche-count":
+ return _ficheCountSort;
+ case "title":
+ return _titleSort;
+ default:
+ return null;
+ }
+ function _rankSort(category1, category2) {
+ let count1 = category1.rank;
+ let count2 = category2.rank;
+ if (count1 > count2) {
+ return -1;
+ } else if (count1 < count2) {
+ return 1;
+ } else {
+ var code1 = category1.name;
+ var code2 = category2.name;
+ if (code1 < code2) {
+ return -1;
+ } else if (code1 > code2) {
+ return 1;
+ } else {
+ return 0;
+ }
+ }
+ }
+ function _ficheCountSort(category1, category2) {
+ let count1 = category1.stats.fiche;
+ let count2 = category2.stats.fiche;
+ if (count1 > count2) {
+ return -1;
+ } else if (count1 < count2) {
+ return 1;
+ } else {
+ return _rankSort(category1, category2);
+ }
+ }
+ function _titleSort(category1, category2) {
+ let title1 = category1.title;
+ let title2 = category2.title;
+ if (!title1) {
+ title1 = "";
+ }
+ if (!title2) {
+ title2 = "";
+ }
+ let comp = compareFunction(title1, title2);
+ if (comp !== 0) {
+ return comp;
+ } else {
+ return _rankSort(category1, category2);
+ }
+ }
+};
+Scrutari.Utils.getLangSortFunction = function (langSortType, locales) {
+ var compareFunction = Scrutari.Utils.getCompareLocaleFunction(locales);
+ switch(langSortType) {
+ case "code":
+ return _codeSort;
+ case "fiche-count":
+ return _ficheCountSort;
+ case "title":
+ return _titleSort;
+ default:
+ return null;
+ }
+ function _codeSort(lang1, lang2) {
+ let code1 = lang1.lang;
+ let code2 = lang2.lang;
+ if (code1 < code2) {
+ return -1;
+ } else if (code1 > code2) {
+ return 1;
+ } else {
+ return 0;
+ }
+ }
+ function _ficheCountSort(lang1, lang2) {
+ let count1 = lang1.fiche;
+ let count2 = lang2.fiche;
+ if (count1 > count2) {
+ return -1;
+ } else if (count1 < count2) {
+ return 1;
+ } else {
+ return _codeSort(lang1, lang2);
+ }
+ }
+ function _titleSort(lang1, lang2) {
+ let title1 = lang1.title;
+ let title2 = lang2.title;
+ if (!title1) {
+ title1 = lang1.lang;
+ }
+ if (!title2) {
+ title2 = lang2.lang;
+ }
+ let comp = compareFunction(title1, title2);
+ if (comp !== 0) {
+ return comp;
+ } else {
+ return _codeSort(lang1, lang2);
+ }
+ }
+};
+Scrutari.Utils.getGroupSortFunction = function (groupSortType) {
+ switch(groupSortType) {
+ case "fiche-count":
+ return _ficheCountSort;
+ default:
+ return null;
+ }
+ function _ficheCountSort(group1, group2) {
+ let count1 = group1.ficheCount;
+ let count2 = group2.ficheCount;
+ if (count1 > count2) {
+ return -1;
+ } else if (count1 < count2) {
+ return 1;
+ } else {
+ let rank1 = group1.category.rank;
+ let rank2 = group1.category.rank;
+ if (rank1 < rank2) {
+ return -1;
+ } else if (rank1 > rank2) {
+ return 1;
+ } else {
+ return 0;
+ }
+ }
+ }
+};
+Scrutari.Utils.mark = function (markArray, classAttribute) {
+ if (!classAttribute) {
+ classAttribute = "scrutari-Mark";
+ }
+ var html = "";
+ var length = markArray.length;
+ for (var i = 0; i < length; i++) {
+ var obj = markArray[i];
+ if (typeof obj === 'string') {
+ html += Scrutari.escape(obj);
+ } else if (obj.s) {
+ html += "";
+ html += Scrutari.escape(obj.s);
+ html += "";
+ }
+ }
+ return html;
+};
+Scrutari.Utils.formatSearchSequence = function (client, scrutariResult) {
+ var q = scrutariResult.getQ();
+ q = q.replace(/\&\&/g, client.loc('_ and'));
+ q = q.replace(/\|\|/g, client.loc('_ or'));
+ return q;
+};
+Scrutari.Utils.render = function (templateString, object) {
+ var result = templateString;
+ for(var key in object) {
+ var normalReplace = new RegExp("{{:" + key + "}}", 'g');
+ var escapeReplace = new RegExp("{{>" + key + "}}", 'g');
+ var value = object[key];
+ result = result.replace(normalReplace, value);
+ result = result.replace(escapeReplace, Scrutari.escape(value));
+ }
+ return result;
+};
+Scrutari.Utils.compareCodebase = function (obj1, obj2) {
+ var code1 = obj1.codebase;
+ var code2 = obj2.codebase;
+ if (code1 < code2) {
+ return -1;
+ } else if (code1 > code2) {
+ return 1;
+ } else {
+ return 0;
+ }
+};
+Scrutari.Utils.compareCodecorpus = function (obj1, obj2) {
+ var code1 = obj1.codecorpus;
+ var code2 = obj2.codecorpus;
+ if (code1 < code2) {
+ return -1;
+ } else if (code1 > code2) {
+ return 1;
+ } else {
+ return 0;
+ }
+};
+Scrutari.Utils.getCompareLocaleFunction = function (locales) {
+ var _localeCompareSupportsLocales = function () {
+ try {
+ "a".localeCompare("b", "i");
+ } catch (exception) {
+ return exception.name === "RangeError";
+ }
+ return false;
+ };
+ var _localesCompare = function (string1, string2) {
+ return string1.localeCompare(string2, locales, {
+ usage: "sort",
+ sensitivity: "base",
+ ignorePunctuation: true});
+ };
+ var _oldCompare = function (string1, string2) {
+ string1 = string1.toLowerCase();
+ string2 = string2.toLowerCase();
+ return string1.localeCompare(string2);
+ };
+ if (_localeCompareSupportsLocales()) {
+ return _localesCompare;
+ } else {
+ return _oldCompare;
+ }
+};
+Scrutari.Utils.buildCorpusMap = function (scrutariMeta, arrays) {
+ var corpusMap = new Object();
+ var finalCount = 0;
+ if (arrays.categoryArray) {
+ finalCount++;
+ var arrayForCategories = scrutariMeta.getCorpusArrayForCategories(arrays.categoryArray);
+ for(var i = 0; i < arrayForCategories.length; i++) {
+ var key = "code_" + arrayForCategories[i];
+ if (corpusMap.hasOwnProperty(key)) {
+ corpusMap[key] = corpusMap[key] + 1;
+ } else {
+ corpusMap[key] = 1;
+ }
+ }
+ }
+ if (arrays.baseArray) {
+ finalCount++;
+ var arrayForBases = scrutariMeta.getCorpusArrayForBases(arrays.baseArray);
+ for(var i = 0; i < arrayForBases.length; i++) {
+ var key = "code_" + arrayForBases[i];
+ if (corpusMap.hasOwnProperty(key)) {
+ corpusMap[key] = corpusMap[key] + 1;
+ } else {
+ corpusMap[key] = 1;
+ }
+ }
+ }
+ if (arrays.corpusArrays) {
+ finalCount++;
+ for(var i = 0; i < arrays.corpusArrays.length; i++) {
+ var key = "code_" + arrays.corpusArrays[i];
+ if (corpusMap.hasOwnProperty(key)) {
+ corpusMap[key] = corpusMap[key] + 1;
+ } else {
+ corpusMap[key] = 1;
+ }
+ }
+ }
+ corpusMap.completeValue = finalCount;
+ return corpusMap;
+};
+Scrutari.Utils.checkKey = function (type, value) {
+ switch(type) {
+ case "base":
+ case "corpus":
+ return "code_" + value;
+ }
+ return value;
+};
+Scrutari.Loc = function (map) {
+ if (map) {
+ this.map = map;
+ } else {
+ this.map = new Object();
+ }
+};
+Scrutari.Loc.prototype.putAll = function (map) {
+ for(var key in map) {
+ this.map[key] = map[key];
+ }
+};
+Scrutari.Loc.prototype.putLoc = function (locKey, locText) {
+ this.map[locKey] = locText;
+};
+Scrutari.Loc.prototype.loc = function (locKey, ...values) {
+ if (!this.map.hasOwnProperty(locKey)) {
+ return locKey;
+ }
+ var text = this.map[locKey];
+ var length = values.length;
+ if ((length === 1) && (Array.isArray(values[0]))) {
+ values = values[0];
+ length = values.length;
+ }
+ if (length > 0) {
+ for(let i = 0; i < length; i++) {
+ let mark = "{" + i + "}";
+ text = text.replace(mark, values[i]);
+ }
+ }
+ return text;
+};
+Scrutari.Loc.prototype.escape = function (locKey, ...values) {
+ if ((values.length === 1) && (Array.isArray(values[0]))) {
+ values = values[0];
+ }
+ return Scrutari.escape(this.loc(locKey, values));
+};
+Scrutari.FilterState = function () {
+ this.empty = true;
+ this.langOnly = true;
+ this.all = {
+ category: true,
+ base: true,
+ corpus: true,
+ lang: true
+ };
+ this.maps = {
+ category: {},
+ base: {},
+ corpus: {},
+ lang: {}
+ };
+ this.titles = {
+ category: [],
+ base: [],
+ corpus: [],
+ lang: []
+ };
+};
+Scrutari.FilterState.prototype.contains = function (type, key) {
+ if (this.all[type]) {
+ return true;
+ }
+ key = Scrutari.Utils.checkKey(type, key);
+ return this.maps[type].hasOwnProperty(key);
+};
+Scrutari.FilterState.prototype.add = function (type, key, title) {
+ this.all[type] = false;
+ this.empty = false;
+ if (type !== "lang") {
+ this.langOnly = false;
+ }
+ key = Scrutari.Utils.checkKey(type, key);
+ if (!this.maps[type].hasOwnProperty(key)) {
+ if (!title) {
+ title = key;
+ }
+ this.maps[type][key] = title;
+ this.titles[type].push(title);
+ }
+};
+Scrutari.Stats = function (scrutariMeta) {
+ this.unitArray = new Array();
+ var maps = {
+ category: {},
+ base: {},
+ corpus: {},
+ lang: {}
+ };
+ this.maps = maps;
+ this.filterState = null;
+ for(let corpus of scrutariMeta.getCorpusArray()) {
+ let langArray = corpus.stats.langArray;
+ let category = scrutariMeta.getCategoryForCorpus(corpus.codecorpus);
+ let categoryName = "";
+ if (category) {
+ categoryName = category.name;
+ }
+ for(let lang of langArray) {
+ let unit = new Scrutari.Stats.Unit(categoryName, corpus.codebase, corpus.codecorpus, lang.lang, lang.fiche);
+ this.unitArray.push(unit);
+ _addInMap("category", unit, categoryName);
+ _addInMap("base", unit, "code_" + corpus.codebase);
+ _addInMap("corpus", unit, "code_" + corpus.codecorpus);
+ _addInMap("lang", unit, lang.lang);
+ }
+ }
+ function _addInMap(type, unit, key) {
+ var map = maps[type];
+ if (!map.hasOwnProperty(key)) {
+ map[key] = new Array();
+ }
+ map[key].push(unit);
+ }
+};
+Scrutari.Stats.prototype.update = function (filterState) {
+ this.filterState = filterState;
+};
+Scrutari.Stats.prototype.getFicheCount = function (type, key) {
+ key = Scrutari.Utils.checkKey(type, key);
+ var map = this.maps[type];
+ if (!map.hasOwnProperty(key)) {
+ return 0;
+ }
+ var count = 0;
+ for(let unit of map[key]) {
+ count += unit.check(this.filterState);
+ }
+ return count;
+};
+Scrutari.Stats.Unit = function (category, base, corpus, lang, value) {
+ this.category = category;
+ this.base = base;
+ this.corpus = corpus;
+ this.lang = lang;
+ this.value = value;
+};
+Scrutari.Stats.Unit.prototype.check = function (filterState) {
+ if (!filterState) {
+ return this.value;
+ }
+ if (!filterState.contains("category", this.category)) {
+ return 0;
+ }
+ if (!filterState.contains("base", this.base)) {
+ return 0;
+ }
+ if (!filterState.contains("corpus", this.corpus)) {
+ return 0;
+ }
+ if (!filterState.contains("lang", this.lang)) {
+ return 0;
+ }
+ return this.value;
+};
+Scrutari.Client = function (scrutariConfig, clientId) {
+ this.scrutariConfig = scrutariConfig;
+ this.clientId = clientId;
+ this.scrutariMeta = null;
+ this.stats = null;
+ this.isWaiting = false;
+ this.mainCurrentScrutariResult = null;
+ this.currentScrutariResult = null;
+ this.options = {
+ withCorpus: false,
+ baseSort: "fiche-count",
+ corpusSort: "fiche-count",
+ categorySort: "rank",
+ langSort: "code",
+ initialQuery: "",
+ initialQId: "",
+ initialFilters: null,
+ permalinkPattern: null,
+ ficheTarget: "_blank",
+ ignoreIcon: false,
+ ignoreThumbnail: false,
+ ficheBodyList: null,
+ mainTitle: null,
+ hooks: {}
+ };
+ this._locInstance = new Scrutari.Loc();
+ this._ignoreArray = new Array();
+ this._ficheBodyTemplateArray = [
+ "fiche_mtitre",
+ "fiche_msoustitre",
+ "fiche_year",
+ "fiche_primaryattributearray",
+ "fiche_mcomplementarray",
+ "fiche_secondaryattributearray",
+ "fiche_motclearray",
+ "fiche_bythesaurusarray"
+ ];
+ this._structureMap = {};
+ this._templateMap = {};
+ this._scrutariResultMap = {};
+ this._historyNumber = 0;
+ this.functions = {};
+ if (typeof SCRUTARI_L10N !== 'undefined') {
+ this._locInstance.putAll(SCRUTARI_L10N);
+ }
+ if (typeof SCRUTARI_HTML !== 'undefined') {
+ this._htmlObject = SCRUTARI_HTML;
+ }
+ if (typeof SCRUTARI_FRAMEWORKINIT === 'function') {
+ SCRUTARI_FRAMEWORKINIT(this);
+ }
+};
+Scrutari.Client.prototype.loc = function (locKey) {
+ return this._locInstance.loc(locKey);
+};
+Scrutari.Client.prototype.toPermalink = function (qId) {
+ if (this.options.permalinkPattern) {
+ return this.scrutariConfig.getPermalinkUrl(qId, this.options.permalinkPattern);
+ }
+ return null;
+};
+Scrutari.Client.prototype.storeResult = function (historyName, scrutariResult) {
+ this._scrutariResultMap[historyName] = scrutariResult;
+};
+Scrutari.Client.prototype.unstoreResult = function (historyName) {
+ this._scrutariResultMap[historyName] = null;
+};
+Scrutari.Client.prototype.getResult = function (historyName) {
+ if (this._scrutariResultMap.hasOwnProperty(historyName)) {
+ return this._scrutariResultMap[historyName];
+ } else {
+ return null;
+ }
+};
+Scrutari.Client.prototype.newHistoryNumber = function () {
+ this._historyNumber++;
+ return this._historyNumber;
+};
+Scrutari.Client.prototype.ignoreElement = function (elementName) {
+ return $.inArray(elementName, this._ignoreArray) > -1;
+};
+Scrutari.Client.prototype.getTemplate = function (templateName) {
+ var template = this.hook("getTemplate", templateName);
+ if (template) {
+ if (typeof template === "function") {
+ return template;
+ } else {
+ Scrutari.log("getTemplate hook does not return function for template name: " + templateName);
+ }
+ }
+ if (templateName.indexOf(":") === -1) {
+ templateName = "scrutari:" + templateName;
+ }
+ template = $.templates[templateName];
+ if (!template) {
+ return function () {
+ return "Unknown template : " + templateName;
+ };
+ } else {
+ return template;
+ }
+};
+Scrutari.Client.prototype.render = function (templateName, context, helpers) {
+ var templateFunction = this.getTemplate(templateName);
+ return templateFunction(context, helpers);
+};
+Scrutari.Client.prototype.hook = function (name) {
+ if (!this.options.hooks.hasOwnProperty(name)) {
+ return;
+ }
+ var hook = this.options.hooks[name];
+ if (typeof hook === "function") {
+ var newArgs = new Array();
+ var argLength = arguments.length;
+ if (argLength > 1) {
+ for(let i = 1; i < argLength; i++) {
+ newArgs.push(arguments[i]);
+ }
+ }
+ hook.apply(this, newArgs);
+ }
+};
+Scrutari.Client.prototype.getFicheBodyTemplateArray = function (fiche, categoryName) {
+ var array = this.hook("getFicheBodyTemplateArray", fiche, categoryName);
+ if (array) {
+ return array;
+ } else {
+ return this._ficheBodyTemplateArray;
+ }
+};
+Scrutari.Client.prototype.$ = function (properties) {
+ return Scrutari.$("#" + this.clientId, properties);
+};
+Scrutari.Client.prototype.$area = function (name, action) {
+ var $area = this.$({scrutariArea: name});
+ if (action) {
+ switch(action) {
+ case 'show':
+ this.show ($area);
+ break;
+ case 'hide':
+ this.hide($area);
+ break;
+ }
+ }
+ return $area;
+};
+Scrutari.Client.prototype.$block = function (name, action) {
+ var $block = this.$({scrutariBlock: name});
+ if (action) {
+ switch(action) {
+ case 'show':
+ this.show ($block);
+ break;
+ case 'hide':
+ this.hide($block);
+ break;
+ }
+ }
+ return $block;
+};
+Scrutari.Client.prototype.$button = function (name, target) {
+ if (target) {
+ return this.$({scrutariButton: name, scrutariTarget: target});
+ } else {
+ return this.$({scrutariButton: name});
+ }
+};
+Scrutari.Client.prototype.$count = function (name, action, value) {
+ var $count = this.$({scrutariCount: name});
+ if (action) {
+ switch(action) {
+ case 'update':
+ if (!value) {
+ value = 0;
+ }
+ Scrutari.$($count, {scrutariRole: "value"}).html(this.formatNumber(value));
+ break;
+ }
+ }
+ return $count;
+};
+Scrutari.Client.prototype.$form = function (name) {
+ return this.$({scrutariForm: name});
+};
+Scrutari.Client.prototype.$group = function (name) {
+ return this.$({scrutariGroup: name});
+};
+Scrutari.Client.prototype.$hidden = function (name, action) {
+ var $hidden = this.$({scrutariHidden: name});
+ if (action) {
+ switch(action) {
+ case 'show':
+ this.show ($hidden);
+ break;
+ case 'hide':
+ this.hide($hidden);
+ break;
+ }
+ }
+ return $hidden;
+};
+Scrutari.Client.prototype.$input = function (name, value) {
+ if (value) {
+ return this.$({_element: "input", _name: name, _value: value});
+ } else {
+ return this.$({_element: "input", _name: name});
+ }
+};
+Scrutari.Client.prototype.$input_checked = function (name, value) {
+ if (value) {
+ return this.$({_element: "input", _name: name, _value: value, _checked: true});
+ } else {
+ return this.$({_element: "input", _name: name, _checked: true});
+ }
+};
+Scrutari.Client.prototype.$label = function (name) {
+ return this.$({scrutariLabel: name});
+};
+Scrutari.Client.prototype.$link = function (name) {
+ return this.$({scrutariLink: name});
+};
+Scrutari.Client.prototype.$modal = function (name, action) {
+ var $modal = this.$({scrutariModal: name});
+ if ((action) && (this.functions.hasOwnProperty("modalAction"))) {
+ this.functions.modalAction($modal, action);
+ }
+ return $modal;
+};
+Scrutari.Client.prototype.$panel = function (name, action) {
+ var $panel = this.$({scrutariPanel: name});
+ if (action) {
+ switch(action) {
+ case 'show':
+ this.show ($panel);
+ break;
+ case 'hide':
+ this.hide($panel);
+ break;
+ }
+ }
+ return $panel;
+};
+Scrutari.Client.prototype.$title = function (name, action) {
+ var $title = this.$({scrutariTitle: name});
+ if (action) {
+ switch(action) {
+ case 'show':
+ this.show ($title);
+ break;
+ case 'hide':
+ this.hide($title);
+ break;
+ }
+ }
+ return $title;
+};
+Scrutari.Client.prototype.show = function (jqArgument) {
+ var $elements = Scrutari.convert(jqArgument);
+ $elements.removeClass("scrutari-Hidden");
+};
+Scrutari.Client.prototype.hide = function (jqArgument) {
+ var $elements = Scrutari.convert(jqArgument);
+ $elements.addClass("scrutari-Hidden");
+};
+Scrutari.Client.prototype.scrollToResult = function () {
+ $(window).scrollTop(this.$area('result').offset().top);
+};
+Scrutari.Client.prototype.getStructureHtml = function (name) {
+ if (this._structureMap.hasOwnProperty(name)) {
+ return this._structureMap[name];
+ } else {
+ Scrutari.log("Unknown structure: " + name);
+ return "";
+ }
+};
+Scrutari.Client.prototype.getStructureNameArray = function () {
+ var result = new Array();
+ for(let prop in this._structureMap) {
+ result.push(prop);
+ }
+ return result;
+};
+Scrutari.Client.prototype.getTemplateHtml = function (name) {
+ if (this._templateMap.hasOwnProperty(name)) {
+ return this._templateMap[name];
+ } else {
+ Scrutari.log("Unknown template: " + name);
+ return "";
+ }
+};
+Scrutari.Client.prototype.formatNumber = function (number) {
+ if (Number.prototype.toLocaleString) {
+ return number.toLocaleString(this.scrutariConfig.lang);
+ } else {
+ return number;
+ }
+};
+Scrutari.Client.init = function (scrutariConfig, clientId, options, callback) {
+ if (!$.templates) {
+ throw new Error("JsRender is not installed");
+ }
+ $.views.helpers("scrutari_mark", function(markArray) {
+ return Scrutari.Utils.mark(markArray);
+ });
+ Scrutari.Meta.load(scrutariConfig, function (scrutariMeta) {
+ var client = new Scrutari.Client(scrutariConfig, clientId);
+ $.views.helpers({
+ scrutari_client: client,
+ scrutari_loc: function(key, ...values) {
+ return client.loc(key, values);
+ },
+ scrutari_format: function(number) {
+ return client.formatNumber(number);
+ }
+ });
+ client.scrutariMeta = scrutariMeta;
+ client.stats = new Scrutari.Stats(scrutariMeta);
+ _checkOptions(client, options, scrutariMeta);
+ _initMaps(client);
+ Scrutari.Client.Ui.init(client);
+ if (callback) {
+ callback(client);
+ }
+ });
+ function _checkOptions (client, options, scrutariMeta) {
+ var defaultOptions = scrutariMeta.getDefaultOptions();
+ for(let key in defaultOptions) {
+ client.options[key] = defaultOptions[key];
+ }
+ if (options) {
+ for(let key in options) {
+ client.options[key] = options[key];
+ }
+ if (options.locMap) {
+ client._locInstance.putAll(options.locMap);
+ }
+ if (options.ignoreList) {
+ let ignoreList = options.ignoreList;
+ let ignoreArray;
+ if (typeof ignoreList === "string") {
+ ignoreArray = ignoreList.split(",");
+ } else if (Array.isArray(ignoreList)) {
+ ignoreArray = ignoreList;
+ }
+ if (ignoreArray) {
+ for(let ignore of ignoreArray) {
+ client._ignoreArray.push(ignore.trim());
+ }
+ }
+ }
+ if (options.ficheBodyList) {
+ let ficheBodyList = options.ficheBodyList;
+ let array1;
+ if (typeof ficheBodyList === "string") {
+ array1 = ficheBodyList.split(",");
+ } else if (Array.isArray(ficheBodyList)) {
+ array1 = ficheBodyList;
+ }
+ if (array1) {
+ let array2 = new Array();
+ for(let token of array1) {
+ token = token.trim();
+ if (token.length > 0) {
+ array2.push(token);
+ }
+ }
+ if (array2.length > 0) {
+ client._ficheBodyTemplateArray = array2;
+ }
+ }
+ }
+ }
+ }
+ function _initHtmlObject (client, htmlObject) {
+ if (htmlObject) {
+ if (htmlObject.structure) {
+ for(var key in htmlObject.structure) {
+ client._structureMap[key] = htmlObject.structure[key];
+ }
+ }
+ if (htmlObject.templates) {
+ for(var key in htmlObject.templates) {
+ client._templateMap[key] = htmlObject.templates[key];
+ }
+ }
+ }
+ }
+ function _initMaps (client) {
+ _initHtmlObject(client, client._htmlObject);
+ _initHtmlObject(client, options.htmlObject);
+ $("script[type='text/x-scrutari-structure']").each(function (index, element) {
+ client._structureMap[element.dataset.name] = $(element).html();
+ });
+ $("script[type='text/x-scrutari-template']").each(function (index, element) {
+ client._templateMap[element.dataset.name] = $(element).html();
+ });
+ for(var name in client._templateMap) {
+ var templateText = client._templateMap[name];
+ templateText = templateText.replace(/tmpl=\"([-_0-9a-z]+)\"/g, 'tmpl="scrutari:$1"');
+ $.templates("scrutari:" + name, templateText);
+ }
+ }
+};
+Scrutari.Client.Result = {};
+Scrutari.Client.Result.show = function (client, scrutariResult, searchOrigin) {
+ client.$hidden("start", 'show');
+ var ficheCount = scrutariResult.getFicheCount();
+ client.$count("stats-result", 'update', ficheCount);
+ var $ficheDisplayBlock = client.$block('ficheDisplay');
+ $ficheDisplayBlock.empty();
+ client.currentScrutariResult = scrutariResult;
+ if (searchOrigin === "mainsearch") {
+ Scrutari.Client.Result.setCurrentMain(client, scrutariResult);
+ Scrutari.Client.Result.addToHistory(client, scrutariResult);
+ } else if (searchOrigin === "subsearch") {
+ let subsearchText = "+ " + Scrutari.Utils.formatSearchSequence(client, scrutariResult) + " = " + scrutariResult.getFicheCount();
+ if (client.currentHistoryName) {
+ Scrutari.$(client.$block(client.currentHistoryName), {scrutariRole: "subsearch"}).text(subsearchText);
+ }
+ }
+ if (ficheCount === 0) {
+ client.$hidden("empty", 'hide');
+ let withFilter;
+ if (searchOrigin === "subsearch") {
+ withFilter = true;
+ } else {
+ withFilter = _hasFilter(scrutariResult.requestParameters);
+ }
+ $ficheDisplayBlock.html(client.render("emptyfichedisplay", {withFilter: withFilter, scrutariResult: scrutariResult}));
+ return;
+ }
+ client.$hidden("empty", 'show');
+ if (ficheCount >= client.scrutariConfig.options.subsearchThreshold) {
+ client.$hidden("threshold", 'show');
+ } else {
+ client.$hidden("threshold", 'hide');
+ }
+ var qId = scrutariResult.getQId();
+ var permalink = client.toPermalink(qId);
+ if (permalink) {
+ client.$link("permalink").attr("href", permalink).html(permalink);
+ }
+ _updateDownloadHref("ods");
+ _updateDownloadHref("csv");
+ _updateDownloadHref("atom");
+ if (scrutariResult.getFicheGroupType() === 'category') {
+ var contextObj = {
+ scrutariResult: scrutariResult,
+ array: new Array()
+ };
+ var categoryCount = scrutariResult.getCategoryCount();
+ for(let i = 0; i < categoryCount; i++) {
+ let category = scrutariResult.getCategory(i);
+ let metaCategory = client.scrutariMeta.getCategory(category.name);
+ if (metaCategory) {
+ category = metaCategory;
+ } else {
+ category.phraseMap = {};
+ category.attrMap = {};
+ }
+ contextObj.array.push({
+ category: category,
+ active: (i === 0),
+ fichestat: scrutariResult.getCategoryFicheCount(i)
+ });
+ }
+ $ficheDisplayBlock.html(client.render("categoryfichedisplay", contextObj));
+ for(let i = 0; i < categoryCount; i++) {
+ let category = scrutariResult.getCategory(i);
+ Scrutari.Client.Result.categoryPaginationChange(client, category.name, 1);
+ }
+ } else {
+ $ficheDisplayBlock.html(client.render("uniquefichedisplay", {scrutariResult: scrutariResult}));
+ Scrutari.Client.Result.uniquePaginationChange(client, 1);
+ }
+ client.hook("showResult", scrutariResult, searchOrigin);
+ function _updateDownloadHref(extension) {
+ client.$link(extension).attr("href", client.scrutariConfig.getDownloadUrl(qId, extension));
+ }
+ function _hasFilter(requestParameters) {
+ for(var prop in requestParameters) {
+ switch(prop) {
+ case "baselist":
+ case "corpuslist":
+ case "categorylist":
+ case "langlist":
+ var value = requestParameters[prop];
+ if (value) {
+ return true;
+ }
+ }
+ if (prop.indexOf("flt") === 0) {
+ return true;
+ }
+ }
+ return false;
+ }
+};
+Scrutari.Client.Result.displayError = function (client, error, searchOrigin) {
+ if (error.parameter !== "q") {
+ Scrutari.logError(error);
+ return;
+ }
+ var title = client.loc(error.key);
+ if (title !== error.key) {
+ var alertMessage = title;
+ if (error.hasOwnProperty("array")) {
+ alertMessage += client.loc('_ colon');
+ for(var i = 0; i < error.array.length; i++) {
+ alertMessage += "\n";
+ var obj = error.array[i];
+ alertMessage += "- ";
+ alertMessage += client.loc(obj.key);
+ if (obj.hasOwnProperty("value")) {
+ alertMessage += client.loc('_ colon');
+ alertMessage += " ";
+ alertMessage += obj.value;
+ }
+ }
+ }
+ alert(alertMessage);
+ } else {
+ Scrutari.logError(error);
+ }
+};
+Scrutari.Client.Result.uniquePaginationChange = function (client, paginationNumber) {
+ var paginationLength = client.scrutariConfig.options.paginationLength;
+ var scrutariResult = client.currentScrutariResult;
+ var html = "";
+ if (!scrutariResult.isUniquePaginationLoaded(paginationLength, paginationNumber)) {
+ if (client.isWaiting) {
+ return;
+ }
+ client.$block("fiches").html(client.render("ficheloading", {scrutariResult: scrutariResult}));
+ client.isWaiting = true;
+ scrutariResult.loadUniquePagination(client.scrutariConfig, paginationLength, paginationNumber, _paginationCallback);
+ return;
+ }
+ var paginationFicheArray = scrutariResult.selectUniqueFicheArray(paginationLength, paginationNumber);
+ var ficheTemplate = client.getTemplate("fiche");
+ for(let fiche of paginationFicheArray) {
+ html += ficheTemplate(Scrutari.Client.Result.completeFiche(client, scrutariResult, fiche));
+ }
+ client.$block("fiches").html(html);
+ var tabArray = Scrutari.Utils.getTabArray(scrutariResult.getFicheCount(), paginationLength, paginationNumber);
+ var template = client.getTemplate("tabs");
+ client.$block("topPagination").html(template({
+ tabArray: tabArray,
+ type: "unique",
+ position: "top"
+ }));
+ client.$block("bottomPagination").html(template({
+ tabArray: tabArray,
+ type: "unique",
+ position: "bottom"
+ }));
+ client.hook("paginationChange", paginationFicheArray, {paginationNumber:paginationNumber});
+ function _paginationCallback () {
+ client.isWaiting = false;
+ Scrutari.Client.Result.uniquePaginationChange(client, paginationNumber);
+ }
+};
+Scrutari.Client.Result.categoryPaginationChange = function (client, categoryName, paginationNumber) {
+ var paginationLength = client.scrutariConfig.options.paginationLength;
+ var scrutariResult = client.currentScrutariResult;
+ var html = "";
+ if (!scrutariResult.isCategoryPaginationLoaded(categoryName, paginationLength, paginationNumber)) {
+ client.$block("fiches_" + categoryName).html(client.render("ficheloading", {scrutariResult: scrutariResult}));
+ if (client.isWaiting) {
+ return;
+ }
+ client.isWaiting = true;
+ scrutariResult.loadCategoryPagination(client.scrutariConfig, categoryName, paginationLength, paginationNumber, _paginationCallback);
+ return;
+ }
+ var paginationFicheArray = scrutariResult.selectCategoryFicheArray(categoryName, paginationLength, paginationNumber);
+ var ficheTemplate = client.getTemplate("fiche");
+ for(let fiche of paginationFicheArray) {
+ html += ficheTemplate(Scrutari.Client.Result.completeFiche(client, scrutariResult, fiche, categoryName));
+ }
+ client.$block("fiches_" + categoryName).html(html);
+ var tabArray = Scrutari.Utils.getTabArray(scrutariResult.getCategoryFicheCountByName(categoryName), paginationLength, paginationNumber);
+ var template = client.getTemplate("tabs");
+ client.$block("topPagination_" + categoryName).html(template({
+ tabArray: tabArray,
+ type: "category",
+ category: categoryName,
+ position: "top"
+ }));
+ client.$block("bottomPagination_" + categoryName).html(template({
+ tabArray: tabArray,
+ type: "category",
+ category: categoryName,
+ position: "bottom"
+ }));
+ client.hook("paginationChange", paginationFicheArray, {categoryName: categoryName, paginationNumber:paginationNumber});
+ function _paginationCallback () {
+ client.isWaiting = false;
+ Scrutari.Client.Result.categoryPaginationChange(client, categoryName, paginationNumber);
+ }
+};
+Scrutari.Client.Result.addToHistory = function (client, scrutariResult) {
+ var $historyListBlock = client.$block("historyList");
+ if (!Scrutari.exists($historyListBlock)) {
+ return;
+ }
+ if (client.currentHistoryName) {
+ var $historyBlock = client.$block(client.currentHistoryName);
+ $historyBlock.removeClass("scrutari-history-Active");
+ Scrutari.$($historyBlock, {scrutariRole: "subsearch"}).empty();
+ client.show(Scrutari.$($historyBlock, {scrutariRole: "remove"}));
+ }
+ var historyName = "history_" + client.newHistoryNumber();
+ Scrutari.Client.Result.setCurrentHistory(client, historyName);
+ client.storeResult(historyName, scrutariResult);
+ var contextObj = {
+ scrutariResult: scrutariResult,
+ name: historyName,
+ fichestat: scrutariResult.getFicheCount(),
+ sequence: Scrutari.Utils.formatSearchSequence(client, scrutariResult)
+ };
+ $historyListBlock.prepend(client.render("history", contextObj));
+};
+Scrutari.Client.Result.loadHistory = function (client, historyName) {
+ var historyScrutariResult = client.getResult(historyName);
+ if (historyScrutariResult) {
+ var $historyBlock = client.$block(historyName);
+ client.currentScrutariResult = historyScrutariResult;
+ Scrutari.Client.Result.setCurrentMain(client, historyScrutariResult);
+ Scrutari.Client.Result.setCurrentHistory(client, historyName);
+ $historyBlock.addClass("scrutari-history-Active");
+ client.hide(Scrutari.$($historyBlock, {scrutariRole: "remove"}));
+ Scrutari.Client.Result.show(client, historyScrutariResult);
+ }
+};
+Scrutari.Client.Result.setCurrentHistory = function (client, historyName) {
+ if (client.currentHistoryName) {
+ var $historyBlock = client.$block(client.currentHistoryName);
+ $historyBlock.removeClass("scrutari-history-Active");
+ Scrutari.$($historyBlock, {scrutariRole: "subsearch"}).empty();
+ client.show (Scrutari.$($historyBlock, {scrutariRole: "remove"}));
+ }
+ client.currentHistoryName = historyName;
+};
+Scrutari.Client.Result.setCurrentMain = function (client, scrutariResult) {
+ client.mainCurrentScrutariResult = scrutariResult;
+ client.$block("currentSearchSequence").text(Scrutari.Utils.formatSearchSequence(client, scrutariResult) + " (" + scrutariResult.getFicheCount() + ")");
+};
+Scrutari.Client.Result.completeFiche = function(client, scrutariResult, fiche, categoryName) {
+ var scrutariMeta = client.scrutariMeta;
+ var options = client.options;
+ Scrutari.Complete.complementTitle(fiche, scrutariMeta);
+ Scrutari.Complete.motcleArray(fiche, _motcleProvider);
+ Scrutari.Complete.bythesaurusArray(fiche, scrutariMeta, _motcleProvider);
+ if (Scrutari.Complete.hasMarkedAttribute(fiche)) {
+ Scrutari.Complete.markedAttributeArray(fiche, scrutariMeta, "primary");
+ Scrutari.Complete.markedAttributeArray(fiche, scrutariMeta, "secondary");
+ }
+ if (!options.ignoreThumbnail) {
+ Scrutari.Complete.thumbnail(fiche);
+ }
+ if (!options.ignoreIcon) {
+ Scrutari.Complete.icon(fiche);
+ }
+ if (options.ficheTarget) {
+ Scrutari.Complete.target(fiche, options.ficheTarget);
+ }
+ fiche._bodyTemplateArray = client.getFicheBodyTemplateArray(fiche, categoryName);
+ client.hook("completeFiche", scrutariResult, fiche, categoryName);
+ return fiche;
+ function _motcleProvider(code) {
+ return scrutariResult.getMotcle(code);
+ }
+};
+Scrutari.Client.Ui = {};
+Scrutari.Client.Ui.filterChange = function (client) {
+ var globalFicheCount = client.scrutariMeta.getGlobalFicheCount();
+ var filterState = Scrutari.Client.Ui.buildFilterState(client);
+ var filterFicheCount;
+ if (filterState.empty) {
+ filterFicheCount = client.scrutariMeta.getGlobalFicheCount();
+ } else {
+ filterFicheCount = -1;
+ }
+ client.stats.update(filterState);
+ if (!_checkFilterFicheCount("base")) {
+ if (!_checkFilterFicheCount("corpus")) {
+ if (!_checkFilterFicheCount("category")) {
+ _checkFilterFicheCount("lang");
+ }
+ }
+ }
+ _updateState("base");
+ _updateState("corpus");
+ _updateState("category");
+ _updateState("lang");
+ var filterTitlesArray = new Array();
+ _addFilterTitles("base", "_ label_base_one", "_ label_base_many");
+ _addFilterTitles("corpus", "_ label_corpus_one", "_ label_corpus_many");
+ _addFilterTitles("lang", "_ label_lang_one", "_ label_lang_many");
+ _addFilterTitles("category", "_ label_category_one", "_ label_category_many");
+ var $filterFicheCount = client.$count('stats-filter', 'update', filterFicheCount);
+ var $filterValue = Scrutari.$($filterFicheCount, {scrutariRole: "value"});
+ if (filterFicheCount === globalFicheCount) {
+ $filterValue.removeClass("scrutari-stats-Filter").removeClass("scrutari-stats-None");
+ client.$hidden('filter', 'hide');
+ } else if (filterFicheCount === 0) {
+ $filterValue.removeClass("scrutari-stats-Filter").addClass("scrutari-stats-None");
+ client.$hidden('filter', 'show');
+ } else {
+ $filterValue.addClass("scrutari-stats-Filter").removeClass("scrutari-stats-None");
+ client.$hidden('filter', 'show');
+ }
+ var $filterTitles = Scrutari.$($filterFicheCount, {scrutariRole: "titles"});
+ if (filterTitlesArray.length > 0) {
+ $filterTitles.html(filterTitlesArray.join(" | "));
+ } else {
+ $filterTitles.html("");
+ }
+ function _checkFilterFicheCount(type) {
+ var $stat = client.$({scrutariStatType: type});
+ if ($stat.length > 0) {
+ filterFicheCount = 0;
+ $stat.each(function (index, element) {
+ let key = element.dataset.scrutariStatKey;
+ filterFicheCount += client.stats.getFicheCount(type, key);
+ });
+ return true;
+ } else {
+ return false;
+ }
+ }
+ function _updateState(type) {
+ client.$({scrutariStatType: type}).each(function (index, element) {
+ var $el = $(element);
+ var key = element.dataset.scrutariStatKey;
+ var ficheCount = client.stats.getFicheCount(type, key);
+ var $statTitle = Scrutari.$parents($el, {scrutariRole: "stat-text"});
+ if (ficheCount != element.dataset.scrutariStatDefault) {
+ if (ficheCount === 0) {
+ $el.html("");
+ $statTitle.addClass("scrutari-panel-Excluded");
+ } else {
+ $statTitle.removeClass("scrutari-panel-Excluded");
+ $el.html(client.formatNumber(ficheCount) + " / ");
+ }
+ } else {
+ $el.html("");
+ $statTitle.removeClass("scrutari-panel-Excluded");
+ }
+ });
+ }
+ function _addFilterTitles(type, oneLocKey, manyLocKey) {
+ var array = filterState.titles[type];
+ if (array.length > 0) {
+ var locKey = (array.length === 1)?oneLocKey:manyLocKey;
+ filterTitlesArray.push(client.loc(locKey) + client.loc('_ colon') + " " + array.join(", "));
+ }
+ }
+};
+Scrutari.Client.Ui.buildRequestParameters = function (client) {
+ var requestParameters = new Object();
+ _checkFilter("baselist", "base");
+ _checkFilter("corpuslist", "corpus");
+ _checkFilter("categorylist", "category");
+ _checkFilter("langlist", "lang");
+ requestParameters["q-mode"] = client.$input_checked("q-mode").val();
+ var ponderation = client.$input_checked("ponderation").val();
+ if (ponderation === 'date') {
+ requestParameters.ponderation = '10,80,5,5';
+ }
+ var periode = $.trim(client.$input("periode").val());
+ if (periode) {
+ requestParameters["flt-date"] = periode;
+ }
+ if (Scrutari.exists(client.$input_checked("wildchar"))) {
+ requestParameters.wildchar = "end";
+ } else {
+ requestParameters.wildchar = "none";
+ }
+ return requestParameters;
+ function _checkFilter (paramName, target) {
+ if (client.$button("enablePanel", target).data("scrutariState") === "on") {
+ var $inputs = client.$input_checked(target);
+ var value = "";
+ for(var i = 0; i < $inputs.length; i++) {
+ if (i > 0) {
+ value += ",";
+ }
+ value += $inputs[i].value;
+ }
+ if (value.length > 0) {
+ requestParameters[paramName] = value;
+ }
+ }
+ }
+};
+Scrutari.Client.Ui.buildFilterState = function (client) {
+ var filterState = new Scrutari.FilterState();
+ _check("base");
+ _check("corpus");
+ _check("category");
+ _check("lang");
+ return filterState;
+ function _check (target) {
+ if (client.$button("enablePanel", target).data("scrutariState") !== "on") {
+ return;
+ }
+ client.$input_checked(target).each(function (index,element) {
+ filterState.add(target, element.value, element.dataset.scrutariTitle);
+ });
+ }
+};
+Scrutari.Client.Ui.init = function (client) {
+ var scrutariMeta = client.scrutariMeta;
+ Scrutari.Client.Ui.initHtml(client);
+ Scrutari.Client.Ui.initForms(client);
+ Scrutari.Client.Ui.initClicks(client);
+ Scrutari.Client.Ui.initMainTitle(client);
+ client.$count('stats-global', 'update', scrutariMeta.getGlobalFicheCount());
+ client.$hidden('init', 'show');
+ client.show(client.$button('parametersDisplay'));
+ var locales = client.scrutariConfig.lang;
+ var langArray = scrutariMeta.getLangArray();
+ if ((langArray.length > 1) && (Scrutari.exists(client.$panel('lang')))) {
+ for(var i = 0, len = langArray.length; i < len; i++) {
+ var title = "";
+ var code = langArray[i].lang;
+ var label = scrutariMeta.getLangLabel(code);
+ if (label !== code) {
+ title = label;
+ }
+ langArray[i].title = title;
+ }
+ var langSortFunction = Scrutari.Utils.getLangSortFunction(client.options.langSort, locales);
+ if (langSortFunction) {
+ langArray = langArray.sort(langSortFunction);
+ }
+ Scrutari.Utils.divideIntoColumns(langArray, client.$group("langColumns"), client.getTemplate("lang"));
+ client.$panel('lang', 'show');
+ }
+ if ((scrutariMeta.withCategory()) && (Scrutari.exists(client.$panel('category')))) {
+ var categoryArray = scrutariMeta.getCategoryArray(Scrutari.Utils.getCategorySortFunction(client.options.categorySort, locales));
+ Scrutari.Utils.divideIntoColumns(categoryArray, client.$group("categoryColumns"), client.getTemplate("category"));
+ client.$panel('category', 'show');
+ }
+ if (client.options.withCorpus) {
+ if (Scrutari.exists(client.$panel('corpus'))) {
+ var corpusArray = scrutariMeta.getCorpusArray(Scrutari.Utils.getCorpusSortFunction(client.options.corpusSort, locales));
+ if (corpusArray.length > 1) {
+ Scrutari.Utils.divideIntoColumns(corpusArray, client.$group("corpusColumns"), client.getTemplate("corpus"));
+ client.$panel('corpus', 'show');
+ }
+ }
+ } else {
+ if (Scrutari.exists(client.$panel('base'))) {
+ var baseArray = scrutariMeta.getBaseArray(Scrutari.Utils.getBaseSortFunction(client.options.baseSort, locales));
+ if (baseArray.length > 1) {
+ Scrutari.Utils.divideIntoColumns(baseArray, client.$group("baseColumns"), client.getTemplate("base"));
+ client.$panel('base', 'show');
+ }
+ }
+ }
+ var initialFilters = client.options.initialFilters;
+ if (initialFilters) {
+ _initFilter("baselist", "base");
+ _initFilter("corpuslist","corpus");
+ _initFilter("categorylist", "category");
+ _initFilter("langlist", "lang");
+ }
+ var initialQuery = client.options.initialQuery;
+ var initialQId = client.options.initialQId;
+ if (initialQuery) {
+ var $mainSearchForm = client.$form('mainsearch');
+ if (Scrutari.exists($mainSearchForm)) {
+ $mainSearchForm.find("input[name='q']").val(initialQuery);
+ $mainSearchForm.submit();
+ }
+ } else if (initialQId) {
+ var requestParameters = Scrutari.Client.Ui.buildRequestParameters(client);
+ requestParameters["qid"] = initialQId;
+ client.$modal("loading", 'show');
+ client.hook("newSearch", requestParameters, "qidsearch");
+ Scrutari.Result.newSearch(client.scrutariConfig, requestParameters, _mainsearchScrutariResultCallback, _mainScrutariErrorCallback);
+ }
+ function _initFilter (optionName, target) {
+ if (!initialFilters.hasOwnProperty(optionName)) {
+ return;
+ }
+ Scrutari.Client.Ui.initFilter(client, target, initialFilters[optionName].split(","));
+ }
+ function _initFilterByQuery (list, target) {
+ if (list) {
+ Scrutari.Client.Ui.initFilter(client, target, list.array);
+ }
+ }
+ function _mainsearchScrutariResultCallback (scrutariResult) {
+ var $mainSearchForm = client.$form('mainsearch');
+ $mainSearchForm.find("input[name='q']").val(scrutariResult.searchMeta.q);
+ $mainSearchForm.find("input[name='q-mode'][value='operation']").click();
+ var searchOptions = scrutariResult.searchMeta.options;
+ if (searchOptions) {
+ _initFilterByQuery(searchOptions.baselist, "base");
+ _initFilterByQuery(searchOptions.corpuslist, "corpus");
+ _initFilterByQuery(searchOptions.categorylist, "category");
+ _initFilterByQuery(searchOptions.langlist, "lang");
+ }
+ Scrutari.Client.Result.show(client, scrutariResult, "mainsearch");
+ client.$modal("loading", 'hide');
+ var $parametersDisplayButton = client.$button('parametersDisplay');
+ if ($parametersDisplayButton.data("scrutariState") === "on") {
+ $parametersDisplayButton.click();
+ }
+ }
+ function _mainScrutariErrorCallback (error) {
+ Scrutari.Client.Result.displayError(client, error, "mainsearch");
+ client.$modal("loading", 'hide');
+ }
+};
+Scrutari.Client.Ui.initHtml = function (client) {
+ var includedTexts = {};
+ var html = _getText("main");
+ html = html.replace(/_ [-_\.a-z0-9]+/g, function(match) {
+ return client.loc(match);
+ });
+ $("#" + client.clientId).html(html);
+ function _getText(name) {
+ if (name.endsWith('*')) {
+ return _getTextByPrefix(name.substring(0, name.length - 1));
+ }
+ if (includedTexts.hasOwnProperty(name)) {
+ Scrutari.log("Already included: " + name);
+ return "";
+ } else if (client.ignoreElement(name)) {
+ return "";
+ } else if ((name === "panel-base") && (client.options.withCorpus)) {
+ return "";
+ } else if ((name === "panel-corpus") && (!client.options.withCorpus)) {
+ return "";
+ } else if ((name === "result-share") && (!client.options.permalinkPattern)) {
+ return "";
+ }
+ includedTexts[name] = true;
+ var text = client.getStructureHtml(name);
+ text = text.replace(/{{([-a-zA-z0-9_]+\*?)}}/g, function (match, p1) {
+ return _getText(p1);
+ });
+ return text;
+ }
+ function _getTextByPrefix(namePrefix) {
+ var result = "";
+ for(let name of client.getStructureNameArray()) {
+ if (name.startsWith(namePrefix)) {
+ let text = _getText(name);
+ if (text.length > 0) {
+ if (result.length > 0) {
+ result = result + "\n";
+ }
+ result = result + text;
+ }
+ }
+ }
+ return result;
+ }
+};
+Scrutari.Client.Ui.initForms = function (client) {
+ client.$form('mainsearch').submit(function () {
+ var q = this["q"].value.trim();
+ if (q.length > 0) {
+ var requestParameters = Scrutari.Client.Ui.buildRequestParameters(client);
+ requestParameters["log"] = "all";
+ requestParameters["q"] = q;
+ client.$modal("loading", 'show');
+ client.hook("newSearch", requestParameters, "mainsearch");
+ Scrutari.Result.newSearch(client.scrutariConfig, requestParameters, _mainsearchScrutariResultCallback, _mainScrutariErrorCallback);
+ }
+ return false;
+ });
+ client.$form('subsearch').submit(function () {
+ var q = this["q"].value.trim();
+ if ((q.length > 0) && (client.mainCurrentScrutariResult)) {
+ var requestParameters = Scrutari.Client.Ui.buildRequestParameters(client);
+ requestParameters["q"] = q;
+ requestParameters["flt-qid"] = client.mainCurrentScrutariResult.getQId();
+ client.$modal("loading", 'show');
+ client.hook("newSearch", requestParameters, "subsearch");
+ Scrutari.Result.newSearch(client.scrutariConfig, requestParameters, _subsearchScrutariResultCallback, _subsearchScrutariErrorCallback);
+ }
+ return false;
+ });
+ function _mainsearchScrutariResultCallback (scrutariResult) {
+ Scrutari.Client.Result.show(client, scrutariResult, "mainsearch");
+ client.$modal("loading", 'hide');
+ var $parametersDisplayButton = client.$button('parametersDisplay');
+ if ($parametersDisplayButton.data("scrutariState") === "on") {
+ $parametersDisplayButton.click();
+ }
+ }
+ function _mainScrutariErrorCallback (error) {
+ Scrutari.Client.Result.displayError(client, error, "mainsearch");
+ client.$modal("loading", 'hide');
+ }
+ function _subsearchScrutariResultCallback (scrutariResult) {
+ Scrutari.Client.Result.show(client, scrutariResult, "subsearch");
+ client.$modal("loading", 'hide');
+ }
+ function _subsearchScrutariErrorCallback (error) {
+ Scrutari.Client.Result.displayError(client, error, "subsearch");
+ client.$modal("loading", 'hide');
+ }
+};
+Scrutari.Client.Ui.initClicks = function (client) {
+ $("#" + client.clientId).on("click", Scrutari.toCssQuery({scrutariButton: true}), function () {
+ var $this = $(this);
+ var action = this.dataset.scrutariButton;
+ var target = this.dataset.scrutariTarget;
+ switch(action) {
+ case 'enablePanel':
+ _enablePanel(this, target);
+ break;
+ case 'checkAll':
+ _checkAll(target);
+ break;
+ case 'uncheckAll':
+ _uncheckAll(target);
+ break;
+ case 'showModal':
+ client.$modal(target, 'show');
+ break;
+ case 'parametersDisplay':
+ let state = Scrutari.Utils.toggle($this, "scrutariState");
+ Scrutari.Utils.toggle.classes($this, state, "Scrutari-On", "");
+ if (state === 'on') {
+ client.$area('parameters', 'show');
+ } else {
+ client.$area('parameters', 'hide');
+ }
+ break;
+ case 'toggleBlock':
+ if (Scrutari.Utils.toggle($this, "scrutariState") === 'on') {
+ client.$block(target, 'show');
+ } else {
+ client.$block(target, 'hide');
+ }
+ break;
+ case 'removeHistory':
+ _removeHistory(target);
+ break;
+ case 'loadHistory':
+ _loadHistory(target);
+ break;
+ case 'categoryTab':
+ _categoryTab(this.dataset.scrutariCategory);
+ break;
+ case 'ficheTab':
+ _ficheTab(this);
+ break;
+ default:
+ Scrutari.log("Unknown action: " + action);
+ }
+ if ((this.tagName) && (this.tagName.toLowerCase() === 'a')) {
+ return false;
+ }
+ });
+ $("#" + client.clientId).on("click", "input", function () {
+ var name = this.name;
+ if (name) {
+ switch(name) {
+ case 'q-mode':
+ if (this.value === 'operation') {
+ Scrutari.Utils.disable("input[name='wildchar']");
+ } else {
+ Scrutari.Utils.enable("input[name='wildchar']");
+ }
+ break;
+ case 'lang':
+ case 'category':
+ case 'base':
+ case 'corpus':
+ _checkClick(name);
+ break;
+ }
+ }
+ });
+ function _checkClick (target) {
+ var $button = client.$button("enablePanel", target);
+ if ($button.data('scrutariState') === 'off') {
+ $button.click();
+ $(this).focus();
+ } else {
+ Scrutari.Client.Ui.filterChange(client);
+ }
+ }
+ function _checkAll (target) {
+ Scrutari.Utils.check("input[name='" + target + "']");
+ Scrutari.Client.Ui.filterChange(client);
+ }
+ function _uncheckAll (target) {
+ Scrutari.Utils.uncheck("input[name='" + target + "']");
+ Scrutari.Client.Ui.filterChange(client);
+ }
+ function _enablePanel (button, target) {
+ var $button = $(button);
+ var state = Scrutari.Utils.toggle($button, "scrutariState");
+ _enableChekButtons();
+ Scrutari.Utils.toggle.classes($button, state, "scrutari-On", "");
+ Scrutari.Utils.toggle.classes(client.$group(target + "Columns"), state, "", "scrutari-panel-ColumnDisabled");
+ Scrutari.Utils.toggle.text($button.children("span"), "scrutariAlternate");
+ var $filterLabel = client.$label(target + "Filter");
+ Scrutari.Utils.toggle.text($filterLabel, "scrutariAlternate");
+ Scrutari.Utils.toggle.classes($filterLabel, state, "scrutari-panel-Active", "scrutari-Disabled");
+ Scrutari.Client.Ui.filterChange(client);
+ function _enableChekButtons () {
+ let disabled = false;
+ if (state === 'off') {
+ disabled = true;
+ }
+ client.$button("checkAll", target).prop('disabled', disabled);
+ client.$button("uncheckAll", target).prop('disabled', disabled);
+ }
+ }
+ function _removeHistory (historyName) {
+ client.unstoreResult(historyName);
+ client.$block(historyName).remove();
+ }
+ function _loadHistory (historyName) {
+ Scrutari.Client.Result.loadHistory(client, historyName);
+ }
+ function _categoryTab (categoryName) {
+ client.$({scrutariRole: "category-content"}).each(function (index, element) {
+ if (element.dataset.scrutariCategory === categoryName) {
+ client.show(element);
+ } else {
+ client.hide(element);
+ }
+ });
+ client.$({scrutariRole: "category-tab"}).each(function (index, element) {
+ if (element.dataset.scrutariCategory === categoryName) {
+ element.classList.add("scrutari-On");
+ } else {
+ element.classList.remove("scrutari-On");
+ }
+ });
+ }
+ function _ficheTab (button) {
+ var newPaginationNumber = parseInt(button.dataset.scrutariNumber);
+ if (button.dataset.scrutariType === "unique") {
+ Scrutari.Client.Result.uniquePaginationChange(client, newPaginationNumber);
+ } else {
+ Scrutari.Client.Result.categoryPaginationChange(client, button.dataset.scrutariCategory, newPaginationNumber);
+ }
+ if (button.dataset.scrutariPosition === "bottom") {
+ client.scrollToResult();
+ }
+ }
+};
+Scrutari.Client.Ui.initMainTitle = function (client) {
+ var html = "";
+ var mainTitle = client.options.mainTitle;
+ if ((mainTitle) || (mainTitle === "")) {
+ if (typeof mainTitle === "function") {
+ html = mainTitle(client);
+ } else {
+ html = mainTitle;
+ }
+ } else {
+ html += client.loc('_ title_main');
+ html += " – ";
+ var title = client.scrutariMeta.getTitle();
+ if (title) {
+ html += Scrutari.escape(title);
+ } else {
+ html += "[";
+ html += client.scrutariConfig.name;
+ html += "]";
+ }
+ }
+ client.$title('main').html(html);
+};
+Scrutari.Client.Ui.initFilter = function (client, target, checkedArray) {
+ var done = false;
+ for(var i = 0, len = checkedArray.length; i < len; i++) {
+ var $input = client.$input(target, checkedArray[i]);
+ if ($input.length > 0) {
+ $input.prop("checked", true);
+ done = true;
+ }
+ }
+ if (done) {
+ client.$button("enablePanel", target).click();
+ }
+};
\ No newline at end of file
diff --git a/squelettes/scrutarijs.html b/squelettes/scrutarijs.html
new file mode 100644
index 0000000..631a573
--- /dev/null
+++ b/squelettes/scrutarijs.html
@@ -0,0 +1,3 @@
+[(#REM) Vincent : Squelette pour le client ScrutariJs
+il se base sur la structure ZCore pour être pleinement intégré]
+