diff --git a/index_5.0.html b/index_5.0.html index 9b807f7..3e9126f 100644 --- a/index_5.0.html +++ b/index_5.0.html @@ -39,7 +39,7 @@ - + diff --git a/js/browseMgr_5.0.js b/js/browseMgr_5.0.js index 67c9d7a..0eb46b9 100644 --- a/js/browseMgr_5.0.js +++ b/js/browseMgr_5.0.js @@ -38,8 +38,9 @@ $(document).ready(function() { const sparqlGenerator = sparqljs.Generator; const myEngine = new Comunica.QueryEngine(); - //const sparqlEndpoint = "https://hdnlab1.isti.cnr.it/fuseki/commediaontosintgra/query"; - const sparqlEndpoint = "https://hdnlab1.isti.cnr.it/fuseki/commedia/query"; + + //const sparqlEndpoint = "https://hdnlab1.isti.cnr.it/fuseki/commedia/query"; + const sparqlEndpoint = "https://lida.dantenetwork.it/fuseki/commedia/query"; var shownSentenceList = new Set() @@ -1994,7 +1995,7 @@ $(document).ready(function() { listaClausoleRisultatoContesti = [] //Unità di ricerca è 'frase' - if ((!listarisultati.length && unitaRicerca == 'forme') || unitaRicerca == 'frase') { + if ((!listarisultati.length && unitaRicerca == 'forme') || unitaRicerca == 'frase' || unitaRicerca == 'versi') { //if (unitaRicerca == 'frase') { unitaRicerca = 'frase' resultsInCantica = [] diff --git a/js/utilsMgr_5.0.js b/js/utilsMgr_5.0.js new file mode 100644 index 0000000..9f2f52b --- /dev/null +++ b/js/utilsMgr_5.0.js @@ -0,0 +1,2180 @@ + + +var hdnquerygrammar = ` +Expression + = head:((_)?"("(_)?("AND "/"OR ") Filtro+ (_)?(")")?){return '{"'+head[3]+'": ['+head[4]+"]}"}//{ return head}.join("").replaceAll(", ,","").replaceAll("(,","(").replaceAll(",("," (")} + / resu:Filtro {return resu[1].split().join()+' ';} +Filtro + = (_)"("?head:(("AND "/"OR "))? tail:(Clausola+ / Filtronick+) (_)? closecl:(")")? + + {if (head != null) return ' {"'+head+'":['+tail+"]}"; + else if (tail!=null & tail.length <2) return ' '+tail+'' + else return ""+tail+"";} + / cl:Clausola + +Clausola + = cla:("Clausola"Integer)(_)? {return ' {"TERM": "'+cla[0]+cla[1]+'"}';} + +Filtronick + =fil:("filtro-"Integer)(_)? {return ' {"TERM": "'+fil[0]+fil[1]+'"}';} + + +Integer "integer" + = _ [0-9]+ { return parseInt(text(), 10); } + +_ "whitespace"= " "* + +` + + + +var testmm = 0 + + + +var ontoSparqlQuerySynt = ` +PREFIX ecrm: +PREFIX orl: +PREFIX ontolex: +PREFIX olires: +PREFIX syntit: +SELECT DISTINCT ?sentence ?clocc ?clfr ?clto ?clafunction ?clatype (?t_canto as ?Canto) (?t_cantica as ?Cantica) +WHERE { + FILTER regex(?Rappresentazione,"^persona$","i") . #remove if query_text=='' + FILTER langMatches(lang(?Rappresentazione),"it") #remove if query_text=='' + ?cat ontolex:writtenRep ?Rappresentazione . #remove if query_text=='' + ?lent ontolex:lexicalForm ?cat; #remove if query_text=='' + ontolex:canonicalForm ?cf. #remove if query_text=='' + ?cf ontolex:writtenRep ?lm. #remove if query_text=='' + ?fa olires:occurrenceOf ?cat . #remove if query_text=='' + ?clocc ecrm:P148_has_component ?fa . #remove if query_text=='' + ?cl syntit:hasClauseType ?clatype; + ecrm:P190_has_symbolic_content ?cltext; + syntit:hasClauseFunction ?clafunction. + ?clocc olires:occurrenceOf ?cl; + olires:occursInRegion ?frag. + ?frag olires:fragmentRegionFrom ?clfr; + olires:fragmentRegionTo ?clto. + ?sentence syntit:Sentence; + ecrm:P148i_is_component_of ?canto; + syntit:hasSyntacticalComponent ?cl. + ?cantica ecrm:P102_has_title ?t_cantica ; + olires:hasStructuralComponent ?canto . + ?canto ecrm:P102_has_title ?t_canto ; + olires:hasNumber ?num . + +} LIMIT 10000 + +` + +//colori per frasi sintattiche + + + +var colorssp = d3.scaleQuantize() + .domain([0, 17]) + .range(["#1f78b4", "#a6cee3", "#b2df8a", "#33a02c", "#fb9a99", "#e31a1c", "#fdbf6f", "#ff7f00", + "#cab2d6", "#6a3d9a", "#ffff99", "#b15928", "#F46D43", + "#D53E4F", "#9E0142", "#e377c2", "#7f7f7f", "#bcbd22"]); +/*.range(["#3288bd", "#66c2a5", "#e41a1c", "#4daf4a", "#984ea3", "#d53e4f", "#f46d43", "#ABDDA4", + "#E6F598", "#FFFFBF", "#FEE08B", "#FDAE61", "#F46D43", + "#D53E4F", "#9E0142", "#e377c2", "#7f7f7f", "#bcbd22"]);*/ + +const mapsynttypestopalette = { + "Ma": 0, "SubI": 1, "SubII": 3, "SubIII": 4, "Co": 5, "Co0": 2, + "CoI": 9, "CoII": 10, "SubIV": 5, "SubV": 6, "ParentethicalClause": 17, + "CoIII": 11, "ParentheticalCo": 14, "PseudoCo": 16, "SubVI": 7, "CoIV": 12, + "CoV": 13, "ParentheticalCoI": 15, "SubVII": 8 +} + +const maptypes = { + "Ma": "Principale", "SubI": "Subordinata I grado", "SubII": "Subordinata II grado", "SubIII": "Subordinata III grado", "Co": "Coordinata", + "CoI": "Coordinata I grado", "CoII": "Coordinata II grado", "SubIV": "Subordinata IV grado", "SubV": "Subordinata V grado", + "ParentethicalClause": "Parentetica", "CoIII": "Coordinata III grado", "ParentheticalCo": "Coordinata alla parentetica", + "PseudoCo": "Pseudo-coordinata", "SubVI": "Subordinata VI grado", "CoIV": "Coordinata IV grado", "CoV": "Coordinata V grado", + "ParentheticalCoI": "Coordinata alla parentetica I grado", "SubVII": "Subordinata VII grado" +} + + + +var orlprefix = 'https://dantenetwork.it/ontology/orl/current/' + +var syntitprefix = 'https://dantenetwork.it/ontology/syntit/current/' + + +function getFraseContext(fraseids, numversi = 3) { + var context = [] + var listaforme = formeprima; + var fraseid = fraseids[0] + + var mainid = fraseid.split('-')[0] + var cantica = mainid.split('_')[0] + var offset = parseInt(fraseid.split('-')[2]); + if (cantica == '2') { + offset = parseInt(fraseid.split('-')[2]) - 33374 + listaforme = formeseconda; + console.log(listaforme.length) + } + + if (cantica == '3') { + offset = parseInt(fraseid.split('-')[2]) - 66588 + listaforme = formeterza; + } + maxpos = listaforme.length - 1 + var pos = 0 + var startindex = Math.max(0, (offset - 20)) + + for (i = startindex; i < listaforme.length; i++) { + var tmpos = listaforme[i].split('_')[2] + if (parseInt(tmpos) == parseInt(fraseid.split('-')[2])) { + pos = i; + break; + } + } + var pos2 = pos + + if (fraseids.length > 1) + lastfraseid = fraseids[fraseids.length - 1] + else + lastfraseid = fraseids[0] + + for (j = pos; j < listaforme.length; j++) { + + var tmpos2 = listaforme[j].split('_')[2] + if (parseInt(tmpos2) == parseInt(lastfraseid.split('-')[3])) { + pos2 = j; + break; + } + } + + + var minpos = 0; + var limitv = Math.max((numversi), 3) + var item = listaforme[pos].split('_'); + var numverso = item[3] + var spannum = (4 * limitv) + + var contextinf = Math.max(minpos, parseInt(pos) - spannum) + var contextsup = Math.min(maxpos, parseInt(pos2) + spannum) + + /*var contextinf = parseInt(fraseid.split('-')[2]) + var contextsup = parseInt(fraseid.split('-')[3])*/ + for (j = contextinf; j < contextsup + 1; j++) { + var tmpform = listaforme[j].split('_'); + if ((tmpform[3] > parseInt(numverso) - limitv) && (tmpform[3] < parseInt(numverso) + limitv)) { + var contextitem = {} + contextitem['testo'] = tmpform[0]; + contextitem['verso'] = tmpform[3]; + contextitem['canto'] = tmpform[1]; + contextitem['cantica'] = cantica - 1; + contextitem['posizione'] = tmpform[2]; + contextitem['catg'] = tmpform[4]; + contextitem['periodo'] = cantica + '_' + tmpform[1] + '_s_' + tmpform[5]; + contextitem['funzperiodo'] = tmpform[6]; + context.push(contextitem); + } + + } + return context; +} + +function getContextLastPosition(formaid, numversi = 3) { + + var listaforme = formeprima; + + var limitv = Math.max((numversi), 3) + var maxpos = 0; + var offset = parseInt(formaid); + + if (parseInt(formaid) > 33373 && parseInt(formaid) < 66588) { + listaforme = formeseconda; + cantica = 1; + offset = parseInt(formaid) - 33374 + + } + if (parseInt(formaid) > 66587 && parseInt(formaid) < 99314) { + listaforme = formeterza; + cantica = 2; + offset = parseInt(formaid) - 66588 + + } + maxpos = listaforme.length - 1 + var pos = 0 + var startindex = Math.max(0, (offset - 25)) + + //console.log('Forma id: '+formaid+' startindex '+ startindex+' offset '+offset+' ('+cantica+')') + for (i = startindex; i < listaforme.length; i++) { + var tmpos = listaforme[i].split('_')[2] + if (tmpos == formaid) { + pos = i; + break; + } + } + + var spannum = (11 * limitv) + + var contextsup = Math.min(maxpos, parseInt(pos) + spannum) + var tmpform = listaforme[contextsup].split('_'); + return (parseInt(tmpform[2])) + + +} +function getFormaContext(formaid, numversi = 3) { + var context = [] + var cantica = 0; + var listaforme = formeprima; + var minpos = 0; + var limitv = Math.max((numversi), 3) + var maxpos = 0; + var offset = parseInt(formaid); + + + /*if (parseInt(formaid) < 33373) { + offset = parseInt(formaid) + }*/ + + if (parseInt(formaid) > 33373 && parseInt(formaid) < 66588) { + listaforme = formeseconda; + cantica = 1; + offset = parseInt(formaid) - 33374 + + } + if (parseInt(formaid) > 66587 && parseInt(formaid) < 99314) { + listaforme = formeterza; + cantica = 2; + offset = parseInt(formaid) - 66588 + + } + if (parseInt(formaid) > 99314 || parseInt(formaid) < 0) { + return []; + } + + + + maxpos = listaforme.length - 1 + var pos = 0 + var startindex = Math.max(0, (offset - 25)) + + //console.log('Forma id: '+formaid+' startindex '+ startindex+' offset '+offset+' ('+cantica+')') + for (i = startindex; i < listaforme.length; i++) { + var tmpos = listaforme[i].split('_')[2] + if (tmpos == formaid) { + pos = i; + //console.log(' in pos: '+pos) + break; + } + } + + + var item = listaforme[pos].split('_'); + var numverso = item[3] + var spannum = (11 * limitv) + + var contextinf = Math.max(minpos, parseInt(pos) - spannum) + var contextsup = Math.min(maxpos, parseInt(pos) + spannum) + for (j = contextinf; j < contextsup + 1; j++) { + var tmpform = listaforme[j].split('_'); + if ((tmpform[3] > parseInt(numverso) - limitv) && (tmpform[3] < parseInt(numverso) + limitv)) { + var contextitem = {} + contextitem['testo'] = tmpform[0]; + contextitem['verso'] = tmpform[3]; + contextitem['canto'] = tmpform[1]; + contextitem['cantica'] = cantica; + contextitem['posizione'] = tmpform[2]; + contextitem['catg'] = tmpform[4]; + contextitem['periodo'] = (parseInt(cantica) + 1) + '_' + tmpform[1] + '_s_' + tmpform[5]; + contextitem['funzperiodo'] = tmpform[6]; + context.push(contextitem); + } + } + return context; + +} + +// the basic initial query is parsed + +function gimmespq() { + var SparqlParser = sparqljs.Parser; + var parser = new SparqlParser(); + return parser.parse(ontoSparqlQuery); + + +} + +// the query is transformed according the form values + +function gimmespqfromjson(form) { + const sparqlgen = sparqljs.Generator; + const generator = new sparqlgen({ orl: "http://www.w3.org/2000/01/rdf-schema#" }) + const parsedquery = gimmespq() + if (form.categoria.value != 'all') + parsedquery.where[0].triples.push(JSON.parse(data21)[form.categoria.value]); + if (form.query.value != "") + switch (form.tipo.value) { + case 'parola': + parsedquery.where[1].expression.args[1].value = "^" + form.query.value + "$"; + break; + case 'sottostringa': + parsedquery.where[1].expression.args[1].value = form.query.value; + break; + case 'prefisso': + parsedquery.where[1].expression.args[1].value = form.query.value; + break; + case 'suffisso': + parsedquery.where[1].expression.args[1].value = form.query.value + "$"; + break; + default: + parsedquery.where[1].expression.args[1].value = "^" + form.query.value + "$"; + }; + return generator.stringify(parsedquery); + +} + +function getStatements() { + + return data21 + +} + + +var theguiQ = '' +var multipleCondSpQuery = '' +var bindConcatStatement = '' +var occBindConcatStatement = '' +var posBindConcatStatement = '' + +var conditions = [] +var filters = [] +var unionop = `{"union": {"type": "union", "patterns":[]}, "bgp": {"type": "bgp", "triples":[]}, "group": {"type": "group", "patterns":[]}}` + + + +function parseJsonClause(op, tokens, nowhere) { + //alert(op) + var idp = -1 + if (nowhere[0].type == 'filter' && nowhere[0].expression.args[0].value == 'Rappresentazione') { + //nowhere.splice(0, 1) + nowhere.splice(0, 2) + } + if (op.trim() == 'OR') { + + //nowhere.splice(1, 0, JSON.parse(unionop)['union']) + nowhere.splice(0, 0, JSON.parse(unionop)['union']) + //idp = 1 + idp = 0 + } + if (op.trim() == 'AND') { + + //nowhere.splice(1, 0, JSON.parse(unionop)['group']) + nowhere.splice(0, 0, JSON.parse(unionop)['group']) + //idp = 1 + idp = 0 + + } + for (var mtoken in tokens) { + te_op = tokens[mtoken] + if ('TERM' in te_op) { + cond = theguiQ[te_op['TERM']] + + multipleCondSpQuery = buildStatementClause(cond, multipleCondSpQuery, -1, nowhere[idp].patterns, mtoken) + + } + else + parseJsonClause(Object.keys(te_op)[0], te_op[Object.keys(te_op)[0]], nowhere.at(-1).patterns) + + } + +} + + +//MULTIPLE CONDITIONS +function buildSPQuery(guiquery) { + theguiQ = ''; + theguiQ = guiquery; + var SparqlParser = sparqljs.Parser; + var spqparser = new SparqlParser(); + if (theguiQ['unitaRicerca'] == 'periodo' || theguiQ['unitaRicerca'] == 'frase' || theguiQ['unitaRicerca'] == 'verso') {//Multiple Conditions UR=Periodo + multipleCondSpQuery = spqparser.parse(sentencetargetquery); + bindConcatStatement = JSON.parse(sentencetarget_functionbind); + occBindConcatStatement = JSON.parse(sentencetarget_occbind); + posBindConcatStatement = JSON.parse(sentencetarget_posbind); + + } + else + multipleCondSpQuery = spqparser.parse(ontoSparqlQueryMultCond); + var parser = peg.generate(hdnquerygrammar); + var test = guiquery['EsprLogica'].join(" "); + test = test.replaceAll("( ", "(") + test = test.replaceAll(" )", ")") + clauses = parser.parse(test); + jsonclauses = JSON.parse(clauses) + + for (const ck of Object.keys(jsonclauses)) { + parseJsonClause(ck, jsonclauses[ck], multipleCondSpQuery.where) + + } + if (theguiQ['unitaRicerca'] == 'periodo' || theguiQ['unitaRicerca'] == 'frase'|| theguiQ['unitaRicerca'] == 'verso') { + multipleCondSpQuery.where.push(bindConcatStatement) + multipleCondSpQuery.where.push(occBindConcatStatement) + + if (posBindConcatStatement['expression']['args'].length) { + multipleCondSpQuery.where.push(posBindConcatStatement) + multipleCondSpQuery.variables.push(JSON.parse(sentencetarget_posVariable)) + //multipleCondSpQuery.where.push(sentencetargetstatement_posCoalesce) + } + + } + +} + +//BUILD THE QUERY! + +function buildSQ(stquery) { + + var filtroContesto; + //stringInSparql = false; + var SparqlParser = sparqljs.Parser; + var parser = new SparqlParser(); + //Prendo la query SPARQL template + var parsedquery = parser.parse(ontoSparqlQuery); + console.log(stquery) + + if (stquery['QueryAvanzata'] == 1 && stquery['EsprLogica'] != null && stquery['EsprLogica'].length > 1) { + //parsedquery = parser.parse(ontoSparqlQueryMultCond) + buildSPQuery(stquery) + return multipleCondSpQuery; + } + + if (stquery['QueryAvanzata'] == 1 && stquery['EsprLogica'] != null && stquery['EsprLogica'] != '' && stquery['EsprLogica'].length == 1) { + clause = stquery['EsprLogica'] + + filtroContesto = getFiltroContestoJson(JSON.parse(stquery[clause[0]]['contesto'])) + + + if (((stquery[clause]['typeSyntax0'].trim() != '' && stquery[clause]['typeSyntax0'].trim() != '.+') || + stquery[clause]['functionSyntax'].trim() != '.+') && + stquery[clause]['typeGramm0'].trim() == 'all') {//solo filtro sintattico + parsedquery = parser.parse(ontoSparqlQuerySynt); + var tempsyntquery = buildSintacticClause(stquery[clause], parsedquery, 2) + if (filtroContesto.length > 0) { + for (tmpc of filtroContesto) { + tempsyntquery.where.splice(0, 0, tmpc) + } + } + return tempsyntquery + } + if ((stquery[clause]['typeSyntax0'].trim() == '.+' && stquery[clause]['functionSyntax'].trim() == '.+') && + stquery[clause]['typeGramm0'].trim() != 'all') {//solo filtro grammaticale + myquery = buildClause(stquery[clause], parsedquery, 2) + if (filtroContesto.length > 0) { + for (tmpc of filtroContesto) { + console.log(filtroContesto[0]) + myquery.where.splice(1, 0, tmpc) + } + + if (stquery[clause]['queryText'].trim() == "") { + if (myquery.where[0].type == 'filter') + myquery.where.splice(0, 1) + } + + } + return (myquery) + } + + } + if (((stquery[clause]['typeSyntax0'].trim() != '' && stquery[clause]['typeSyntax0'].trim() != '.+') || + (stquery[clause]['functionSyntax'].trim() != '' && stquery[clause]['functionSyntax'].trim() != '.+')) && + stquery[clause]['typeGramm0'].trim() != 'all') {//entrambi i filtri + console.log('entrambi i filtri') + //preparo la query sparql + var tmpCont=stquery[clause]['contesto'] + var tmpCl0=stquery['Clausola0'] + var tmpUnric=stquery['unitaRicerca'] + + var tmpCl2= { + "queryText": stquery[clause]["queryText"], + "lemma_forma": stquery[clause]["lemma_forma"], + "opzioni_testo": stquery[clause]["opzioni_testo"], + "TipoClausola": "Sintattico", + "Attiva": "1", + "typeSyntax0": stquery[clause]["typeSyntax0"], + "functionSyntax": stquery[clause]["functionSyntax"], + "contesto": tmpCont + } + + var tmpCl1J=stquery['Clausola1'] + //var tmpCl1J= JSON.parse(tC1); + delete tmpCl1J['typeSyntax0']; + delete tmpCl1J['functionSyntax']; + tmpCl1J["TipoClausola"]="Grammaticale" + var tmpJ={ + "EsprLogica": ["(","AND","Clausola1","Clausola2",")"], + "LogicaGui": ["(","AND","Clausola1","Clausola2",")"], + "QueryAvanzata": "1", + "unitaRicerca": tmpUnric, + "LiDaVersion": "1.0", + "Clausola0": tmpCl0, + "Clausola1":tmpCl1J, + "Clausola2": tmpCl2 + } + console.log(tmpJ); + buildSPQuery(tmpJ); + return multipleCondSpQuery; + + } + + //Simple query + + filtroContestoJson = getFiltroContestoJson(JSON.parse(stquery['Clausola0']['contesto'])) + if (filtroContestoJson.length > 0) { + for (tmpc of filtroContestoJson) { + //console.log(filtroContesto[0]) + parsedquery.where.splice(1, 0, tmpc) + } + + + } + + if (stquery['Clausola0']['queryText'] != "" && stquery['Clausola0']['Attiva'] == 1) { + searchtext = stquery['Clausola0']['queryText'] + let strval = searchtext + + if (stquery['Clausola0']['opzioni_testo'] == 'parola') { + strval = "^" + searchtext.trim() + "$"; + } + if (stquery['Clausola0']['opzioni_testo'] == 'sottostringa') { + strval = searchtext.trim(); + } + if (stquery['Clausola0']['opzioni_testo'] == 'suffisso') { + strval = searchtext.trim() + "$"; + } + if (stquery['Clausola0']['opzioni_testo'] == 'prefisso') { + strval = "^" + searchtext.trim(); + } + + + + + parsedquery.where[0].expression.args[1].value = strval; + if (stquery['Clausola0']['lemma_forma'] == 'lemma') { + parsedquery.where[0].expression.args[0].value = "lm"; + parsedquery.where.splice(1, 1) + parsedquery.where[1].patterns[0].triples.splice(0, 1) + } + + } + else { + console.log('Simple query, no param') + parsedquery.where.splice(0, 1) + } + + return (parsedquery) + +} + + + +//Filtro Contesto + + +function getFiltroContestoJson(datiContesto) { + var cantica = 0; + var canticheids = new Set() + for (contestoCantica of datiContesto) { + var contextids = [] + cantica++; + for (const [index, element] of contestoCantica.entries()) { + if (element == 1) { + //console.log('Cantica ' + cantica + ', Canto ' + (parseInt(index) + 1)); + contextids.push(parseInt(index) + 1) + } + } + if (contextids.length > 0) { + canticheids[cantica] = contextids + } + } + + if (Object.keys(canticheids).length > 0) { + + //console.log(JSON.stringify(canticheids)) + var test = buildFilterContextJson(canticheids) + + return (test) + } + else + return [] +} + +function buildStatementClause(clause, parsedquery, whereind, theplace, token) { + // + var tmpgroup = '' + if (clause['TipoClausola'] == "Sintattico") { + if (theguiQ['unitaRicerca'] == 'periodo' || theguiQ['unitaRicerca'] == 'frase' || theguiQ['unitaRicerca'] == 'verso') + tmpgroup = JSON.parse(sentencetarget_syntgroup) + else + tmpgroup = JSON.parse(syntgroup) + } + if (clause['TipoClausola'] == "Grammaticale") { + if (theguiQ['unitaRicerca'] == 'periodo' || theguiQ['unitaRicerca'] == 'frase' || theguiQ['unitaRicerca'] == 'verso') { + tmpgroup = JSON.parse(sentencetarget_morphgroup_short) + } + + else + tmpgroup = JSON.parse(morphgroup) + } + + + if (clause['queryText'] != null && clause['queryText'].trim() != "") { + + + var stmt = buildFilterStatement(clause['lemma_forma'], clause['queryText'].trim(), clause['opzioni_testo']) + tmpgroup.patterns.unshift(stmt) + //tmpgroup.patterns.push(JSON.parse(unionop)['bgp']); + tmpgroup.patterns.splice(1, 0, JSON.parse(unionop)['bgp']); + if (clause['lemma_forma'] == 'lemma') { + tmpgroup.patterns.at(-1).triples.push(JSON.parse(lemma_lexicalform)) + tmpgroup.patterns.at(-1).triples.push(JSON.parse(lemma_canonicalform)) + tmpgroup.patterns.at(-1).triples.push(JSON.parse(lemma_writtenrepresentation)) + } + else { + tmpgroup.patterns[1].triples.push(JSON.parse(writtenrepresentation)) + //tmpgroup.patterns.at(-1).triples.push(JSON.parse(writtenrepresentation)) + } + + } + + if (clause['typeGramm0'] != null && clause['typeGramm0'] != "all") + if (whereind > -1) + parsedquery.where[whereind].triples.push(JSON.parse(data21)[clause['typeGramm0']]); + else { + tmpgroup.patterns.push(JSON.parse(unionop)['bgp']); + tmpgroup.patterns.at(-1).triples.push(JSON.parse(data21)[clause['typeGramm0']]); + + } + + if (clause['typeGramm0'] != null && Object.keys(sottoCategorie).includes(clause['typeGramm0'].trim())) { + + sctmp = sottoCategorie[clause['typeGramm0'].trim()] + sctk = Object.keys(sctmp) + for (ke in sctk) { + + keval = clause[sctk[ke]] + if (keval != null && keval != '') { + sttmts = sctmp[sctk[ke]] + if (sttmts[keval] != null && (sttmts[keval].split(':')[1]) != null) { + subcatstat = buildsubcategoryClause(sttmts[keval]) + if (whereind > -1) + parsedquery.where[whereind].triples.push(subcatstat); + else + //theplace.at(-1).triples.push(subcatstat); + tmpgroup.patterns.at(-1).triples.push(subcatstat); + } + } + } + } + + if (clause['TipoClausola'] == 'Grammaticale') { + if (theguiQ['unitaRicerca'] == 'periodo' || theguiQ['unitaRicerca'] == 'frase' || theguiQ['unitaRicerca'] == 'verso') { + var tmpg = JSON.stringify(tmpgroup) + tmpg = tmpg.replaceAll('"Rappresentazione"', '"Rappresentazione' + token + '"') + tmpg = tmpg.replaceAll('"form"', '"form' + token + '"') + tmpg = tmpg.replaceAll('"lent"', '"lent' + token + '"') + tmpg = tmpg.replaceAll('"cf"', '"cf' + token + '"') + tmpg = tmpg.replaceAll('"fa"', '"fa' + token + '"') + tmpg = tmpg.replaceAll('"pos"', '"pos' + token + '"') + tmpg = tmpg.replaceAll('"lm"', '"lm' + token + '"') + tmpg = tmpg.replaceAll('"reg"', '"reg' + token + '"') + tmpg = tmpg.replaceAll('"clg"', '"clg' + token + '"') + tmpg = tmpg.replaceAll('"cloccte"', '"cloccte' + token + '"') + tmpgroup = JSON.parse(tmpg) + var tmppos = `{ + "type": "operation", + "operator": "str", + "args": [ + { + "termType": "Variable", + "value": "pos`+ token + `" + } + ] + } + ` + posBindConcatStatement['expression']['args'].push(JSON.parse(tmppos)) + tmppos = `{ + "termType": "Literal", + "value": ";", + "language": "", + "datatype": { + "termType": "NamedNode", + "value": "http://www.w3.org/2001/XMLSchema#string" + } + }` + posBindConcatStatement['expression']['args'].push(JSON.parse(tmppos)) + } + } + + // CLAUSOLA SINTATTICA + + if (clause['TipoClausola'] == "Sintattico") { + tmpgroup.patterns.push(JSON.parse(unionop)['bgp']); + + //controllo se tra i filtri c'e una stringa + if (clause['queryText'] != null && clause['queryText'].trim() != "") { + //aggiungo statements per legare la stringa alla clausola + + tmpgroup.patterns[1].triples.push(JSON.parse(occurrenceof_form)) + tmpgroup.patterns[1].triples.push(JSON.parse(clauseocc_hascomponent_formocc)) + tmpgroup.patterns[1].triples.push(JSON.parse(occurrenceof_clause)) + } + var functS = clause['functionSyntax']; + var typeS = clause['typeSyntax0'] + console.log(functS + ' ' + typeS) + var myf = '' + if (functS != null && functS != ".+") { + myf = buildsyntClause(funzione_clausola[functS]) + if (myf != '') + tmpgroup.patterns.at(-1).triples.push(myf) + } + if (typeS != null && typeS != ".+") { + var alltipi = Object.assign(macrotipi_sint, tipi_sint); + let mymt = alltipi[typeS] + + if (listaMacroTipiConSubTipo.includes(mymt.split(':')[1])) { + let myfa = buildMacroSyntType(mymt) + for (fa in myfa) { + //tmpgroup.patterns.at(-1).triples.push(myfa[fa]) + tmpgroup.patterns.push(myfa[fa]) + } + } + else { + var tmptr = alltipi[typeS].split(';') + for (indttr in tmptr) { + myf = buildsyntClause(tmptr[indttr]) + if (myf != '') + tmpgroup.patterns.at(-1).triples.push(myf) + } + + } + + } + if (theguiQ['unitaRicerca'] == 'periodo' || theguiQ['unitaRicerca'] == 'frase' || theguiQ['unitaRicerca'] == 'verso') { + mytest = JSON.stringify(tmpgroup) + mytest = mytest.replaceAll(':"cl"', ':"cl' + token + '"') + mytest = mytest.replaceAll(':"clatype"', ':"clatype' + token + '"') + mytest = mytest.replaceAll(':"clafunction"', ':"clafunction' + token + '"') + mytest = mytest.replaceAll(':"cloccu"', ':"cloccu' + token + '"') + mytest = mytest.replaceAll(':"fa"', ':"fa' + token + '"') + mytest = mytest.replaceAll(':"form"', ':"form' + token + '"') + mytest = mytest.replaceAll(':"Rappresentazione"', ':"Rappresentazione' + token + '"') + var mystrb = `{ + "type": "operation", + "operator": "str", + "args": [ + { + "termType": "Variable", + "value": "clafunction`+ token + `" + } + ] + } + ` + bindConcatStatement['expression']['args'].push(JSON.parse(mystrb)) + mystrb = `{ + "type": "operation", + "operator": "str", + "args": [ + { + "termType": "Variable", + "value": "cl`+ token + `" + } + ] + } + ` + occBindConcatStatement['expression']['args'].push(JSON.parse(mystrb)) + mystrb = `{ + "termType": "Literal", + "value": ";", + "language": "", + "datatype": { + "termType": "NamedNode", + "value": "http://www.w3.org/2001/XMLSchema#string" + } + }` + bindConcatStatement['expression']['args'].push(JSON.parse(mystrb)) + occBindConcatStatement['expression']['args'].push(JSON.parse(mystrb)) + tmpgroup = JSON.parse(mytest) + + + } + } + + theplace.push(tmpgroup) + + return parsedquery + +} + + + +function buildSintacticClause(clause, parsedquery, whereind) { + + if (clause['queryText'].trim() != "") { + + var strval = getStringFilter(clause['queryText'].trim(), clause['opzioni_testo']) + parsedquery.where[0].expression.args[1].value = strval; + if (clause['lemma_forma'] == 'lemma') + parsedquery.where[0].expression.args[0].value = "lm"; + } + else { + if (parsedquery.where[0].type == 'filter' && parsedquery.where[0].expression.args[0].value == 'Rappresentazione') + //remove the filter for text CHANGE! + parsedquery.where.splice(0, 1) + parsedquery.where.splice(0, 1) + parsedquery.where[0].triples.splice(5, 1) + parsedquery.where[0].triples.splice(4, 1) + parsedquery.where[0].triples.splice(3, 1) + parsedquery.where[0].triples.splice(2, 1) + parsedquery.where[0].triples.splice(1, 1) + parsedquery.where[0].triples.splice(0, 1) + whereind = whereind - 1 + } + + + var functS = clause['functionSyntax']; + var typeS = clause['typeSyntax0'] + console.log(functS + ' ' + typeS) + if (functS != null && functS != ".+") { + //console.log('functS '+funzione_clausola['princ']) + var myf = buildsyntClause(funzione_clausola[functS]) + + if (myf == '') + return parsedquery + parsedquery.where.at(-1).triples.push(myf); + } + if (typeS != null && typeS != ".+") { + var alltipi = Object.assign(macrotipi_sint, tipi_sint); + let mymt = alltipi[typeS] + if (listaMacroTipiConSubTipo.includes(mymt.split(':')[1])) { + let myfa = buildMacroSyntType(mymt) + for (fa in myfa) { + //parsedquery.where.at(-1).triples.push(myfa[fa]) + parsedquery.where.push(myfa[fa]) + } + } + else { + + var tmptr = macrotipi_sint[typeS].split(';') + for (indttr in tmptr) { + myf = buildsyntClause(tmptr[indttr]) + if (myf != '') + parsedquery.where.at(-1).triples.push(myf) + } + } + + + } + return parsedquery +} + +function buildClause(clause, parsedquery, whereind) { + + if (clause['TipoClausola'] == 'Sintattico') + return buildSintacticClause(clause, parsedquery, whereind) + + + + if (clause['typeGramm0'] != null && clause['typeGramm0'] != "all") + if (whereind > -1) + //parsedquery.where[whereind].triples.push(JSON.parse(data21)[clause['typeGramm0']]); + parsedquery.where[2].patterns[0].triples.splice(0, 0, JSON.parse(data21)[clause['typeGramm0']]); + else { + parsedquery.where.at(-1).patterns.push(JSON.parse(unionop)['bgp']); + parsedquery.where.at(-1).patterns.at(-1).triples.push(JSON.parse(data21)[clause['typeGramm0']]); + } + + + if (clause['typeGramm0'] != null && Object.keys(sottoCategorie).includes(clause['typeGramm0'].trim())) { + //sctmp=JSON.parse(sottoCategorieSostantivi) + sctmp = sottoCategorie[clause['typeGramm0'].trim()] + sctk = Object.keys(sctmp) + for (ke of sctk) { + + keval = clause[ke] + if (keval != null && keval != '') { + sttmts = sctmp[ke] + if (sttmts[keval] != null && (sttmts[keval].split(':')[1]) != null) { + subcatstat = buildsubcategoryClause(sttmts[keval]) + if (whereind > -1) + parsedquery.where[2].patterns[0].triples.push(subcatstat); + else + parsedquery.where.at(-1).patterns.at(-1).triples.push(subcatstat); + } + } + } + } + + if (clause['queryText'].trim() != "") { + + var strval = getStringFilter(clause['queryText'].trim(), clause['opzioni_testo']) + parsedquery.where[0].expression.args[1].value = strval; + if (clause['lemma_forma'] == 'lemma') + parsedquery.where[0].expression.args[0].value = "lm"; + } + else { + if (parsedquery.where[0].type == 'filter' && parsedquery.where[0].expression.args[0].value == 'Rappresentazione') + parsedquery.where.splice(0, 1) + whereind = whereind - 1 + } + + return parsedquery + +} + +function getStringFilter(filter, opzione) { + var strval = "^" + filter.trim() + "$"; + if (opzione != "") + switch (opzione) { + case 'parola': + strval = "^" + filter.trim() + "$"; + break; + case 'sottostringa': + strval = filter.trim(); + break; + case 'prefisso': + strval = "^" + filter.trim(); + break; + case 'suffisso': + strval = filter.trim() + "$"; + break; + default: + strval = "^" + filter.trim() + "$"; + + }; + return (strval) +} +//costruzione filtri per query + +//filtri contesto +function buildFilterContextJson(contextcantiche) { + var resfilters = [] + + var contextgroup = ` { + "type": "group", + "patterns": [ + { + "type": "bgp", + "triples": [ + {"subject": {"termType": "Variable","value": "cantica"}, + "predicate": {"termType": "NamedNode","value": "http://erlangen-crm.org/current/P102_has_title"}, + "object": {"termType": "Variable","value": "t_cantica"}}, + {"subject": {"termType": "Variable","value": "cantica"}, + "predicate": {"termType": "NamedNode","value": "https://dantenetwork.it/ontology/olires/current/hasStructuralComponent"}, + "object": {"termType": "Variable","value": "canto"}}, + {"subject": {"termType": "Variable","value": "canto"}, + "predicate": {"termType": "NamedNode","value": "https://dantenetwork.it/ontology/olires/current/hasNumber"}, + "object": {"termType": "Variable","value": "num"}} + + ] + } + ] + } + +` + + var filtercontexttemplate = `{ + "type": "filter", + "expression": { + "type": "operation", + "operator": "in", + "args": [ + { + "termType": "Variable", + "value": "num" + } + ] + } + }` + + var filtercontextcantichetemplate = `{ + "type": "filter", + "expression": { + "type": "operation", + "operator": "in", + "args": [ + { + "termType": "Variable", + "value": "t_cantica" + } + ] + } + }` + + var itemcontexttemplate = ` + { + "termType": "Literal", + "value": "na", + "language": "", + "datatype": { + "termType": "NamedNode", + "value": "http://www.w3.org/2001/XMLSchema#short" + } + }` + var canticacontexttemplate = ` + { + "termType": "Literal", + "value": "na", + "language": "", + "datatype": { + "termType": "NamedNode", + "value": "http://www.w3.org/2001/XMLSchema#string" + } + }` + + + var canticheliteral = ['Inferno', 'Purgatorio', 'Paradiso'] + + for (var ky in contextcantiche) { + var contextfilter = [] + var cantichecontextfilter = [] + var cgroup = JSON.parse(contextgroup) + if (contextcantiche.hasOwnProperty(ky)) { + ///console.log(`test ${ky} : ${contextcantiche[ky]}`) + + var cfilter = JSON.parse(canticacontexttemplate); + + cfilter['value'] = canticheliteral[ky - 1] + cantichecontextfilter.push(cfilter) + for (var kval in contextcantiche[ky]) { + //console.log(contextcantiche[ky][kval]) + var myfilter = JSON.parse(itemcontexttemplate); + myfilter['value'] = contextcantiche[ky][kval].toString() + contextfilter.push(myfilter) + } + } + if (contextfilter.length > 0) { + var filters = JSON.parse(filtercontexttemplate) + var cantichefilters = JSON.parse(filtercontextcantichetemplate) + filters['expression']['args'].push(contextfilter) + + //resfilters.push(filters) + cgroup.patterns.splice(0, 0, filters) + cantichefilters['expression']['args'].push(cantichecontextfilter) + + cgroup.patterns.splice(0, 0, cantichefilters) + resfilters.push(cgroup) + } + + } + var uniontmp = `{"type": "union", "patterns":[]}` + var tmpres = [] + jsunion = JSON.parse(uniontmp) + if (resfilters.length > 1) { + + for (filter in resfilters) { + jsunion.patterns.push(resfilters[filter]) + } + tmpres.push(jsunion) + return (tmpres) + } + if (resfilters.length > 0) { + + tmpres.push(resfilters[0].patterns[1]) + tmpres.push(resfilters[0].patterns[0]) + } + return (tmpres) + +} + + +function buildFilterStatement(target, filter, opzione) { + + var filtertemplate = `{ + "type": "filter", + "expression": { + "type": "operation", + "operator": "regex", + "args": [ + { + "termType": "Variable", + "value": "Rappresentazione" + }, + { + "termType": "Literal", + "value": "^andare$", + "language": "", + "datatype": { + "termType": "NamedNode", + "value": "http://www.w3.org/2001/XMLSchema#string" + } + }, + { + "termType": "Literal", + "value": "i", + "language": "", + "datatype": { + "termType": "NamedNode", + "value": "http://www.w3.org/2001/XMLSchema#string" + } + } + ] + } +}` + + + var statement = JSON.parse(filtertemplate) + /* + if (filter.trim().slice(-1) !== '*') + strval = "^" + filter.trim() + "$"; + else + strval = filter.trim().slice(0, -1) + */ + var strval = getStringFilter(filter, opzione); + + statement.expression.args[1].value = strval; + if (target == 'lemma') + statement.expression.args[0].value = "lm"; + + return (statement) +} + + +//"hasClauseType:Comparativa" +// +//?cl syntit:hasClauseType ?tipoSint . +//?tipoSint rdf:type syntit:ClauseSubType ; +// ecrm:P127_has_broader_term syntit:Comparativa . + +function buildMacroSyntType(sttmnt) { + var uniontmpms = `{"type": "union", "patterns":[]}` + var trm1 = `{ + "type": "bgp", + "triples": + [ + {"subject": {"termType": "Variable","value": "cl"}, + "predicate": {"termType": "NamedNode", "value": "https://dantenetwork.it/ontology/syntit/current/hasClauseType"}, + "object": {"termType": "Variable","value": "tipoSint"}}, + {"subject": {"termType": "Variable","value": "tipoSint"}, + "predicate": {"termType": "NamedNode","value": "http://www.w3.org/1999/02/22-rdf-syntax-ns#type"}, + "object": {"termType": "NamedNode", "value": "https://dantenetwork.it/ontology/syntit/current/ClauseSubType"}}, + {"subject": {"termType": "Variable","value": "tipoSint"}, + "predicate": {"termType": "NamedNode","value": "http://erlangen-crm.org/current/P127_has_broader_term"}, + "object": {"termType": "NamedNode"}} + + ] + }` + var tmplate = `{"subject": {"termType": "Variable", "value":"cl"}, + "predicate": {"termType":"NamedNode"}, + "object": {"termType": "NamedNode"}}` + + var t1m = `{"subject": {"termType": "Variable","value": "cl"}, + "predicate": {"termType": "NamedNode", "value": "https://dantenetwork.it/ontology/syntit/current/hasClauseType"}, + "object": {"termType": "Variable","value": "tipoSint"}}` + var t2m = `{"subject": {"termType": "Variable","value": "tipoSint"}, + "predicate": {"termType": "NamedNode","value": "http://www.w3.org/1999/02/22-rdf-syntax-ns#type"}, + "object": {"termType": "NamedNode", "value": "https://dantenetwork.it/ontology/syntit/current/ClauseSubType"}}` + var t3m = `{"subject": {"termType": "Variable","value": "tipoSint"}, + "predicate": {"termType": "NamedNode","value": "http://erlangen-crm.org/current/P127_has_broader_term"}, + "object": {"termType": "NamedNode"}}` + var res = [] + + + + var obj = syntitprefix + (sttmnt.split(':')[1]) + + var predicate = syntitprefix + (sttmnt.split(':')[0]) + + var statement = JSON.parse(tmplate) + + statement['predicate']['value'] = predicate + statement['object']['value'] = obj + + var grstmt = JSON.parse(trm1) + grstmt['triples'][2]['object']['value'] = obj + + var unionst = JSON.parse(uniontmpms) + unionst['patterns'].push(grstmt) + unionst['patterns'].push(statement) + res.push(unionst) + //var statement = JSON.parse(t3m) + //statement['object']['value'] = obj + //res.push(JSON.parse(t1m)) + //res.push(JSON.parse(t2m)) + //res.push(statement) + return res +} + +function buildsyntClause(sttmnt) { + + + var tmplate = `{"subject": {"termType": "Variable", "value":"cl"}, + "predicate": {"termType":"NamedNode"}, + "object": {"termType": "NamedNode"}} + ` + + + console.log(sttmnt) + + var predicate = syntitprefix + (sttmnt.split(':')[0]) + var obj = syntitprefix + (sttmnt.split(':')[1]) + var statement = JSON.parse(tmplate) + + statement['predicate']['value'] = predicate + statement['object']['value'] = obj + + return (statement) + +} + +function buildsubcategoryClause(sttmnt) { + + subcattmplate = `{"subject": {"termType": "Variable", "value":"form"}, + "predicate": {"termType":"NamedNode"}, + "object": {"termType": "NamedNode"}} + ` + + predicate = orlprefix + (sttmnt.split(':')[0]) + obj = orlprefix + (sttmnt.split(':')[1]) + subcatstatement = JSON.parse(subcattmplate) + + subcatstatement['predicate']['value'] = predicate + subcatstatement['object']['value'] = obj + + return (subcatstatement) + +} +//GESTIONE CITAZIONI/COMMENTI +//return JSON object +/*function getVersiConCitazioniJson(canticapar = '', cantopar = '') { + let citcantiche = ['Inferno', 'Purgatorio', 'Paradiso'] + if (canticapar == '') { + citazioni.map(function(item) { + console.log(item['Cantica'] + ', ' + item['Canto'] + ', ' + item['Verso'].split('-')[0]); + }) + return + } + var citazionitemp = {} + citazioni.map(function(item) { + if (item['Cantica'] == canticapar && item['Canto'] == cantopar) { + + let tca = item['Canto'] + if (tca.startsWith('0')) + tca = tca.replace('0', '') + let citid = (citcantiche.indexOf(item['Cantica']) + 1).toString() + '_' + tca + '_' + item['Verso']//.split('-')[0] + //console.log(citid) + var commentsItem = {} + commentsItem['verso'] = citid; + commentsItem['annotazione'] = item['Ann']; + commentsItem['commentario'] = item['Com']; + commentsItem['frammentoNota'] = item['FrN']; + commentsItem['AutoreCitazione'] = item['AC']; + commentsItem['FonteCitazione'] = item['F']; + commentsItem['LuogoFonteCitazione'] = item['LF']; + commentsItem['NotaFonteCitazione'] = item['NF']; + commentsItem['TestoFonteCitazione'] = item['TF']; + commentsItem['URLFonteCitazione'] = item['UF']; + commentsItem['NaturaRiferimento'] = item['NaRi']; + commentsItem['RapportoCommentoCommentatoreText'] = item['RCC']; + commentsItem['RapportoSoggettoOggetto'] = item['RSO']; + commentsItem['NomeAutoreCitazione'] = item['Aut']; + commentsItem['TitoloFonteCitazione'] = item['TiFo']; + commentsItem['VersoCitazione'] = item['Verso']; + + if (item['AC'] == '') { + commentsItem['AutoreCitazione'] = 'autore' + } + + if (item['TiCi'] == 'no') { + commentsItem['TipoCitazione'] = '' + } + else { + commentsItem['TipoCitazione'] = item['TiCi'] + } + //'CEP', 'CIM', 'CTE', 'CMO', 'CST', 'CTO' + + if (item['CEP'] == 'no') { + commentsItem['CitEpisodi'] = '' + } + else { + commentsItem['CitEpisodi'] = item['CEP'] + } + + if (item['CIM'] == 'no') { + commentsItem['CitImmagini'] = '' + } + else { + commentsItem['CitImmagini'] = item['CIM'] + } + + if (item['CTE'] == 'no') { + commentsItem['CitTeorie'] = '' + } + else { + commentsItem['CitTeorie'] = item['CTE'] + } + + if (item['CMO'] == 'no') { + commentsItem['CitMotivi'] = '' + } + else { + commentsItem['CitMotivi'] = item['CMO'] + } + + if (item['CST'] == 'no') { + commentsItem['CitStilemi'] = '' + } + else { + commentsItem['CitStilemi'] = item['CST'] + } + + if (item['CTO'] == 'no') { + commentsItem['CitTopografie'] = '' + } + else { + commentsItem['CitTopografie'] = item['CTO'] + } + + if (citazionitemp.hasOwnProperty(citid)) { + citazionitemp[citid].push(commentsItem) + } + else { + var tmpar = [] + tmpar.push(commentsItem) + citazionitemp[citid] = tmpar + } + } + + }) + console.log(citazionitemp) + return citazionitemp; +} + +//inizializzazione UI per query sulle citazioni +function getAutoriFontiCitazioni() { + var listaAutori = new Set() + citazioni.map(function(item) { + listaAutori.add(item['Aut']); + + if (item['Aut'] == '') { + listaAutori.add('Sconosciuto') + } + + }) + + return Array.from(listaAutori) +} + +function getCommentatori() { + var listaCommentatori = new Set() + citazioni.map(function(item) { + listaCommentatori.add(item['Com']); + + if (item['Com'] == '') { + listaCommentatori.add('Sconosciuto') + } + + }) + + return Array.from(listaCommentatori) +} +*/ +const myiframe = document.getElementsByClassName("minimap__content"); +function resetGraphStruct() { + + var periodograph = document.getElementById("periodograph"); + if (periodograph != null) { + let showngr = document.getElementById("periodograph").getAttribute('name').split("_") + var tmpsent = showngr[0] + "_" + showngr[1] + "_s_" + showngr[2] + periodograph.parentNode.removeChild(periodograph); + + //var sentence = document.getElementsByClassName(lsentid); + var sentence = document.getElementsByClassName(tmpsent); + + for (let i = 0; i < sentence.length; i++) { + //var matches = listaClausoleRisultato.filter(s => s.includes(sentence[i].classList[0])); + sentence[i].classList.remove('font-italic'); + if (!vistaPeriodi && !listaPeriodiRisultato.includes(tmpsent) + && listaClausoleRisultato.filter(cl => cl.split('-')[0] == tmpsent).length == 0) + sentence[i].style.removeProperty('color'); + + sentence[i].classList.remove('font-weight-normal'); + + } + + //reset Minimap + var iframeDocument = myiframe[0].contentDocument || myiframe[0].contentWindow.document; + if (!iframeDocument) { + throw "iframe couldn't be found in DOM."; + } + var iframeSentence = iframeDocument.getElementsByClassName(tmpsent); + for (let i = 0; i < iframeSentence.length; i++) { + iframeSentence[i].classList.remove('font-italic'); + if (!vistaPeriodi) + iframeSentence[i].style.removeProperty('color'); + + iframeSentence[i].classList.remove('font-weight-normal'); + } + //EMPTY CARD + emptyStructCard() + + if (tmpsent == lsentid) { + + return true + } + + return false + + } +} +//end + +var sottoCategorie = { + "verbovolgare": { + "Diatesi": { "Attivo": "TipoDiatesiVerboVolgare:VerboVolgareAttivo", "Passivo": "TipoDiatesiVerboVolgare:VerboVolgarePassivo" }, + "Transitivita": { "Intransitivo": "TipoTransitivitàVerboVolgare:VerboVolgareIntransitivo", "Transitivo": "TipoTransitivitàVerboVolgare:VerboVolgareTransitivo" }, + "Genere": { "Femminile": "TipoGenereVerboVolgare:GenereFemminileVerboVolgare", "Maschile": "TipoGenereVerboVolgare:GenereMaschileVerboVolgare" }, + "Numero": { "Singolare": "TipoNumeroVerboVolgare:NumeroSingolareVerboVolgare", "Plurale": "TipoNumeroVerboVolgare:NumeroPluraleVerboVolgare" }, + "Pers": { "Impersonale": "VerboVolgareImpersonale:VerboVolgareImpersonale" }, + "Rifl": { "Riflessivo": "VerboVolgareRiflessivo:VerboVolgareRiflessivo" }, + "Coniugazione": { + "Prima coniugazione": "TipoConiugazioneVerboVolgare:VerboVolgarePrimaConiugazione", "Seconda coniugazione": "TipoConiugazioneVerboVolgare:VerboVolgareSecondaConiugazione", + "Terza coniugazione": "TipoConiugazioneVerboVolgare:VerboVolgareTerzaConiugazione", + "Essere coniugazione": "TipoConiugazioneVerboVolgare:VerboVolgareAusiliareEssere", + "Avere coniugazione": "TipoConiugazioneVerboVolgare:VerboVolgareAusiliareAvere" + }, + "Tempi": { + "Indicativo presente": "TipoTempoVerboVolgare:PresenteIndicativoVerboVolgare", "Indicativo passato prossimo": "TipoTempoVerboVolgare:PassatoProssimoIndicativoVerboVolgare", + "Indicativo imperfetto": "TipoTempoVerboVolgare:ImperfettoIndicativoVerboVolgare", "Indicativo passato remoto": "TipoTempoVerboVolgare:PassatoRemotoIndicativoVerboVolgare", + "Indicativo trapassato prossimo": "TipoTempoVerboVolgare:TrapassatoProssimoIndicativoVerboVolgare", "Indicativo trapassato remoto": "TipoTempoVerboVolgare:TrapassatoRemotoIndicativoVerboVolgare", + "Indicativo futuro semplice": "TipoTempoVerboVolgare:FuturoSempliceIndicativoVerboVolgare", "Indicativo futuro anteriore": "TipoTempoVerboVolgare:FuturoAnterioreIndicativoVerboVolgare", + "Congiuntivo presente": "TipoTempoVerboVolgare:PresenteCongiuntivoVerboVolgare", "Congiuntivo imperfetto": "TipoTempoVerboVolgare:ImperfettoCongiuntivoVerboVolgare", + "Congiuntivo passato": "TipoTempoVerboVolgare:PassatoCongiuntivoVerboVolgare", "Congiuntivo trapassato": "TipoTempoVerboVolgare:TrapassatoCongiuntivoVerboVolgare", + "Condizionale presente": "TipoTempoVerboVolgare:PresenteCondizionaleVerboVolgare", "Condizionale passato": "TipoTempoVerboVolgare:PassatoCondizionaleVerboVolgare", + "Imperativo presente": "TipoTempoVerboVolgare:PresenteImperativoVerboVolgare", "Infinito presente": "TipoTempoVerboVolgare:PresenteInfinitoVerboVolgare", + "Infinito passato": "TipoTempoVerboVolgare:PassatoInfinitoVerboVolgare", "Participio presente": "TipoTempoVerboVolgare:PresenteParticipioVerboVolgare", + "Participio passato": "TipoTempoVerboVolgare:PassatoParticipioVerboVolgare", "Gerundio presente": "TipoTempoVerboVolgare:PresenteGerundioVerboVolgare", + "Gerundio passato": "TipoTempoVerboVolgare:PassatoGerundioVerboVolgare" + }, + "Funzione": { + "Aggettivo": "TipoFunzioneVerboVolgare:VerboVolgareFunzioneAggettivo", "Sostantivo maschile": "TipoFunzioneVerboVolgare:VerboVolgareFunzioneSostantivoMaschile", + "Sostantivo femminile": "TipoFunzioneVerboVolgare:VerboVolgareFunzioneSostantivoFemminile" + }, + "Declinazione": { + "Prima declinazione": "TipoDeclinazioneVerboVolgare:PrimaDeclinazioneVerboVolgare", "Seconda declinazione": "TipoDeclinazioneVerboVolgare:SecondaDeclinazioneVerboVolgare", + "Terza declinazione": "TipoDeclinazioneVerboVolgare:TerzaDeclinazioneVerboVolgare" + }, + "Persona": { + "1ª persona singolare": "TipoPersonaVerboVolgare:PrimaPersonaSingolareVerboVolgare", "2ª persona singolare": "TipoPersonaVerboVolgare:SecondaPersonaSingolareVerboVolgare", + "3ª persona singolare": "TipoPersonaVerboVolgare:TerzaPersonaSingolareVerboVolgare", "1ª persona plurale": "TipoPersonaVerboVolgare:PrimaPersonaPluraleVerboVolgare", + "2ª persona plurale": "TipoPersonaVerboVolgare:SecondaPersonaPluraleVerboVolgare", "3ª persona plurale": "TipoPersonaVerboVolgare:TerzaPersonaPluraleVerboVolgare" + } + + }, + + "sostantivovolgare": { + "Genere_lemma": { "Lemma femminile": "TipoGenereLemmaSostantivoVolgare:GenereFemminileLemmaSostantivoVolgare", "Lemma maschile": "TipoGenereLemmaSostantivoVolgare:GenereMaschileLemmaSostantivoVolgare" }, + "Genere_forma": { "Forma femminile": "TipoGenereSostantivoVolgare:GenereFemminileSostantivoVolgare", "Forma maschile": "TipoGenereSostantivoVolgare:GenereMaschileSostantivoVolgare" }, + "Numero": { "Singolare": "TipoNumeroSostantivoVolgare:NumeroSingolareSostantivoVolgare", "Plurale": "TipoNumeroSostantivoVolgare:NumeroPluraleSostantivoVolgare" }, + "riflpers": { "In locuzione": "SostantivoVolgareInLocuzione:Lv_lv" }, + "Declinazione_sostantivo": { + "Prima declinazione": "TipoDeclinazioneSostantivoVolgare:PrimaDeclinazioneSostantivoVolgare", "Seconda declinazione": "TipoDeclinazioneSostantivoVolgare:SecondaDeclinazioneSostantivoVolgare", + "Terza declinazione": "TipoDeclinazioneSostantivoVolgare:TerzaDeclinazioneSostantivoVolgare" + } + }, + + "pronomevolgare": { + "Genere": { "Femminile": "generePronomeVolgare:PronomeVolgareFemminile", "Maschile": "generePronomeVolgare:PronomeVolgareMaschile" }, + "Numero": { "Singolare": "TipoNumeroPronomeVolgare:PronomeVolgareSingolare", "Plurale": "TipoNumeroPronomeVolgare:PronomeVolgarePlurale" }, + "Classe_Persona": { + "1ª": "TipoClassePersonaPronomeVolgare:PronomeVolgarePrimaClassePersona", + "2ª": "TipoClassePersonaPronomeVolgare:PronomeVolgareSecondaClassePersona", + "3ª": "TipoClassePersonaPronomeVolgare:PronomeVolgareTerzaClassePersona" + }, + "Tipo": { + "Personale": "TipoDelPronomeVolgare:PronomePersonaleVolgare", + "Riflessivo": "TipoDelPronomeVolgarePronomeRiflessivoVolgare", + "Interrogativo": "TipoDelPronomeVolgare:PronomeInterrogativoVolgare", + "Esclamativo": "TipoDelPronomeVolgare:PronomeEsclamativoVolgare", + "Dimostrativo": "TipoDelPronomeVolgare:PronomeDimostrativoVolgare", + "Relativo": "TipoDelPronomeVolgare:PronomeRelativoVolgare", + "Possessivo": "TipoDelPronomeVolgare:PronomePossessivoVolgare" + }, + "Forma_Personali_Riflessivi": { + "Libero": "TipoFormaPerRifPronomeVolgare:PronomeLiberoVolgare", + "Libero in Composizione": "TipoFormaPerRifPronomeVolgare:PronomeLiberoInComposizioneVolgare", + "Proclitico": "TipoFormaPerRifPronomeVolgare:PronomeProcliticoVolgare", "Enclitico": "TipoFormaPerRifPronomeVolgare:PronomeEncliticoVolgare" + }, + "Funzione_Personali": { + "Libero - soggetto": "TipoFunzionePronomeVolgare:PronomeVolgareLiberoSoggetto", + "Libero - soggetto impersonale": "TipoFunzionePronomeVolgare:PronomeVolgareLiberoSoggettoImpersonale", + "Libero - complemento": "TipoFunzionePronomeVolgare:PronomeVolgareLiberoComplemento", "Libero - rafforzativo": "TipoFunzionePronomeVolgare:PronomeVolgareLiberoRafforzativo", + "Clitico - accusativo": "TipoFunzionePronomeVolgare:PronomeVolgareCliticoAccusativo", "Clitico - dativo": "TipoFunzionePronomeVolgare:PronomeVolgareCliticoDativo", + "Clitico - partitivo": "TipoFunzionePronomeVolgare:PronomeVolgareCliticoPartitivo" + }, + "Tipo_Riflessivi": { + "Proprio": "TipoRiflessiviDelPronomeVolgare:PronomeVolgareProprio", "Lessicalizzato": "TipoRiflessiviDelPronomeVolgare:PronomeVolgareLessicalizzato", + "Impersonale": "TipoRiflessiviDelPronomeVolgare:PronomeVolgareImpersonale", "Passivo": "TipoRiflessiviDelPronomeVolgare:PronomeVolgarePassivo", + "Reciproco": "TipoRiflessiviDelPronomeVolgare:PronomeVolgareReciproco" + } + + }, + + "aggettivovolgare": { + "Classe": { "1ª": "TipoClasseAggettivoVolgare:AggettivoVolgarePrimaClasse", "2ª": "TipoClasseAggettivoVolgare:AggettivoVolgareSecondaClasse" }, + "Genere": { "Femminile": "TipoGenereAggettivoVolgare:AggettivoVolgareFemminile", "Maschile": "TipoGenereAggettivoVolgare:AggettivoVolgareMaschile" }, + "Numero": { "Singolare": "TipoNumeroAggettivoVolgare:AggettivoVolgareSingolare", "Plurale": "TipoNumeroAggettivoVolgare:AggettivoVolgarePlurale" }, + "Con_oggetto_indiretto": { "Con oggetto indiretto": "AggettivoVolgareConOggettoIndiretto:AggettivoVolgareConOggettoIndiretto" }, + "Tipo_aggettivo": { + "Qualificativo": "TipoDellAggettivoVolgare:AggettivoQualificativoVolgare", + "Indefinito": "TipoDellAggettivoVolgare:AggettivoIndefinitoVolgare", "Interrogativo": "TipoDellAggettivoVolgare:AggettivoInterrogativoVolgare", + "Esclamativo": "TipoDellAggettivoVolgare:AggettivoEsclamativoVolgare", "Numerale": "TipoDellAggettivoVolgare:AggettivoNumeraleVolgare", + "Dimostrativo": "TipoDellAggettivoVolgare:AggettivoDimostrativoVolgare", "Relativo": "TipoDellAggettivoVolgare:AggettivoRelativoVolgare", + "Possessivo": "TipoDellAggettivoVolgare:AggettivoPossessivoVolgare", "In locuzione": "TipoDellAggettivoVolgare:AggettivoVolgareInLocuzione" + }, + "Grado": { + "Comparativo di maggioranza": "TipoGradoAggettivoVolgare:AggettivoVolgareComparativoDiMaggioranza", "Comparativo di minoranza": "TipoGradoAggettivoVolgare:AggettivoVolgareComparativoDiMinoranza", + "Comparativo di uguaglianza": "TipoGradoAggettivoVolgare:AggettivoVolgareComparativoDiUgualianza", "Superlativo relativo": "TipoGradoAggettivoVolgare:AggettivoVolgareSuperlativorelativo", + "Superlativo assoluto": "TipoGradoAggettivoVolgare:AggettivoVolgareSuperlativoAssoluto" + }, + "Tipo_di_Complemento": { + "Introdotto da A": "TipoDiCompelementoAggettivoVolgare:AggettivoVolgareIntrodottoDaA", "Introdotto da CON": "TipoDiCompelementoAggettivoVolgare:AggettivoVolgareIntrodottoDaCON", + "Introdotto da CONTRO": "TipoDiCompelementoAggettivoVolgare:AggettivoVolgareIntrodottoDaCONTRO", "Introdotto da DA": "TipoDiCompelementoAggettivoVolgare:AggettivoVolgareIntrodottoDaDA", + "Introdotto da DI": "TipoDiCompelementoAggettivoVolgare:AggettivoVolgareIntrodottoDaDI", "Introdotto da IN": "TipoDiCompelementoAggettivoVolgare:AggettivoVolgareIntrodottoDaIN", + "Introdotto da PER": "TipoDiCompelementoAggettivoVolgare:AggettivoVolgareIntrodottoDaPER", "Introdotto da SU": "TipoDiCompelementoAggettivoVolgare:AggettivoVolgareIntrodottoDaSU", + "Introdotto da TRA": "TipoDiCompelementoAggettivoVolgare:AggettivoVolgareIntrodottoDaTRA", "Introdotto da VERSO": "TipoDiCompelementoAggettivoVolgare:AggettivoVolgareIntrodottoDaVERSO", + "Introdotto da SOPRA": "TipoDiCompelementoAggettivoVolgare:AggettivoVolgareIntrodottoDaSOPRA", "Introdotto da SOTTO": "TipoDiCompelementoAggettivoVolgare:AggettivoVolgareIntrodottoDaSOTTO", + "Introdotto da DINANZI": "TipoDiCompelementoAggettivoVolgare:AggettivoVolgareIntrodottoDaDINANZI", "Introdotto da prep.": "TipoDiCompelementoAggettivoVolgare:AggettivoVolgareIntrodottoDaPreposizione", + "Oggetto ind.": "TipoDiCompelementoAggettivoVolgare:AggettivoVolgareOggettoInd", "Ogg. indi. + compl. con DI": "TipoDiCompelementoAggettivoVolgare:AggettivoVolgareOggettoIndComplConDI", + "Ogg. ind. pronom.": "TipoDiCompelementoAggettivoVolgare:AggettivoVolgareOggettoIndPronom" + }, + "Tipo_di_frase": { + "Con infinito retto da A": "TipoDiFraseAggettivoVolgare:AggettivoVolgareConInfinitoRettoDaA", "Con infinito retto da DA": "TipoDiFraseAggettivoVolgare:AggettivoVolgareConInfinitoRettoDaDA", + "Con infinito retto da DI": "TipoDiFraseAggettivoVolgare:AggettivoVolgareConInfinitoRettoDaDI", "Con infinito retto da PER": "TipoDiFraseAggettivoVolgare:AggettivoVolgareConInfinitoRettoDaPER", + "Con infinito retto da SE": "TipoDiFraseAggettivoVolgare:AggettivoVolgareConInfinitoRettoDaSE", "Con subordinata all'indic.": "TipoDiFraseAggettivoVolgare:AggettivoVolgareConSubordinataAllIndicativo", + "Con subordinata al cong.": "TipoDiFraseAggettivoVolgare:AggettivoVolgareConSubordinataAlCongiuntivo", "In locuzione imp.+infinito": "TipoDiFraseAggettivoVolgare:AggettivoVolgareInLocuzioneImpInfinito", + "In locuzione imp.+che+indic.": "TipoDiFraseAggettivoVolgare:AggettivoVolgareInLocuzioneImpCheIndicativo", "In locuzione imp.+che+cong.": "TipoDiFraseAggettivoVolgare:AggettivoVolgareInLocuzioneImpCheCongiuntivo", + "In locuzione imp.+se+indic.": "TipoDiFraseAggettivoVolgare:AggettivoVolgareInLocuzioneImpSeIndicativo", "In locuzione imp.+se+cong.": "TipoDiFraseAggettivoVolgare:AggettivoVolgareInLocuzioneImpSeCongiuntivo", + "In locuzione imp.+come+indic.": "TipoDiFraseAggettivoVolgare:AggettivoVolgareInLocuzioneImpComeIndicativo", "In locuzione imp.+quando+indic.": "TipoDiFraseAggettivoVolgare:AggettivoVolgareInLocuzioneImpQuandoIndicativo", + "In locuzione imp.+perché+cong.": "TipoDiFraseAggettivoVolgare:AggettivoVolgareInLocuzioneImpPerchéCongiuntivo", "In locuzione imp.+a+infinito": "TipoDiFraseAggettivoVolgare:AggettivoVolgareInLocuzioneImpAInfinito" + } + + }, + + "articolovolgare": { + "Genere": { "Femminile": "TipoGenereArticoloVolgare:ArticoloVolgareFemminile", "Maschile": "TipoGenereArticoloVolgare:ArticoloVolgareMaschile" }, + "Numero": { "Singolare": "TipoNumeroArticoloVolgare:ArticoloVolgareSingolare", "Plurale": "TipoNumeroArticoloVolgare:ArticoloVolgarePlurale" }, + "Tipo": { "Determinativo": "TipoDellArticoloVolgare:ArticoloVolgareDeterminativo", "Indeterminativo": "TipoDellArticoloVolgare:ArticoloVolgareIndeterminativo" } + + }, + "avverbiovolgare": { + "Tipo": { + "Al comparativo di maggioranza": "TipoDellAvverbioVolgare:AvverbioVolgareAlComparativoDiMaggioranza", + "Al comparativo di minoranza": "TipoDellAvverbioVolgare:AvverbioVolgareAlComparativoDiMinoranza", + "Al superlativo assoluto": "TipoDellAvverbioVolgare:AvverbioVolgareAlSuperlativoAssoluto", + "Al superlativo relativo": "TipoDellAvverbioVolgare:AvverbioVolgareAlSuperlativoRelativo", + "In Locuzione": "TipoDellAvverbioVolgare:AvverbioVolgareInLocuzione", + "In Locuzione separato": "TipoDellAvverbioVolgare:AvverbioVolgareInLocuzioneSeparato", + "Proclitico": "TipoDellAvverbioVolgare:AvverbioVolgareProclitico", + "Enclitico": "TipoDellAvverbioVolgare:AvverbioVolgareEnclitico", + "Al comparativo di ugualianza": "TipoDellAvverbioVolgare:AvverbioVolgareAlComparativoDiUgualianza" + } + }, + + "preposizionevolgare": { + "Tipo_I": { + "Propria": "TipoIDellaPreposizioneVolgare:PreposizioneVolgarePropria", + "Impropria": "TipoIDellaPreposizioneVolgare:PreposizioneVolgareImpropria" + }, + "Tipo_preposizione": { + "Semplice": "TipoIIDellaPreposizioneVolgare:PreposizioneVolgareSemplice", + "Articolata": "TipoIIDellaPreposizioneVolgare:PreposizioneVolgareArticolata", + "In locuzione": "TipoIIDellaPreposizioneVolgare:PreposizioneVolgareInLocuzione", + "In locuzione separata": "TipoIIDellaPreposizioneVolgare:PreposizioneVolgareInLocuzioneSeparata" + }, + "Sintassi": { + "Soggettiva": "TipoSintassiPreposizioneVolgare:PreposizioneVolgareSoggettiva", "Oggettiva": "TipoSintassiPreposizioneVolgare:PreposizioneVolgareOggettiva", + "Dichiarativa": "TipoSintassiPreposizioneVolgare:PreposizioneVolgareDichiarativa", "Completiva obliqua": "TipoSintassiPreposizioneVolgare:PreposizioneVolgareCompletivaObliqua", + "Finale": "TipoSintassiPreposizioneVolgare:PreposizioneVolgareFinale", + "Causale": "TipoSintassiPreposizioneVolgare:PreposizioneVolgareCausale", + "Concessiva": "TipoSintassiPreposizioneVolgare:PreposizioneVolgareConcessiva", + "Consecutiva": "TipoSintassiPreposizioneVolgare:PreposizioneVolgareConsecutiva", + "Temporale": "TipoSintassiPreposizioneVolgare:PreposizioneVolgareTemporale", + "Modale": "TipoSintassiPreposizioneVolgare:PreposizioneVolgareModale", + "Eccettuativa": "TipoSintassiPreposizioneVolgare:PreposizioneVolgareEccettuativa", + "Esclusiva": "TipoSintassiPreposizioneVolgare:PreposizioneVolgareEsclusiva", + "Limitativa": "TipoSintassiPreposizioneVolgare:PreposizioneVolgareLimitativa", + "Comparativa": "TipoSintassiPreposizioneVolgare:PreposizioneVolgareComparativa", + "Avversativa": "TipoSintassiPreposizioneVolgare:PreposizioneVolgareAvversativa" + }, + "Complemento_(I)": { + "Di stato in luogo": "TipoComplementoIPreposizioneVolgare:PreposizioneVolgareDiStatoInLuogo", + "Di moto a luogo": "TipoComplementoIPreposizioneVolgare:PreposizioneVolgareDiMotoALuogo", + "Di moto da luogo": "TipoComplementoIPreposizioneVolgare:PreposizioneVolgareDiMotoDaLuogo", + "Di moto per luogo": "TipoComplementoIPreposizioneVolgare:PreposizioneVolgareDiMotoPerLuogo", + "Di luogo": "TipoComplementoIPreposizioneVolgare:PreposizioneVolgareDiLuogo", + "Predicativo del soggetto": "TipoComplementoIPreposizioneVolgare:PreposizioneVolgarePredicativoDelSoggetto", + "Predicativo dell'oggetto": "TipoComplementoIPreposizioneVolgare:PreposizioneVolgarePredicativoDellOggetto", + "Di distanza": "TipoComplementoIPreposizioneVolgare:PreposizioneVolgareDiDistanza", + "Di tempo determinato": "TipoComplementoIPreposizioneVolgare:PreposizioneVolgareDiTempoDeterminato", + "Di tempo continuato": "TipoComplementoIPreposizioneVolgare:PreposizioneVolgareDiTempoContinuato", + "Di tempo": "TipoComplementoIPreposizioneVolgare:PreposizioneVolgareDiTempo", + "Di termine": "TipoComplementoIPreposizioneVolgare:PreposizioneVolgareDiTermine", + "Di vantaggio": "TipoComplementoIPreposizioneVolgare:PreposizioneVolgareDiVantaggio", + "Di svantaggio": "TipoComplementoIPreposizioneVolgare:PreposizioneVolgareDiSvantaggio", + "Di specificazione": "TipoComplementoIPreposizioneVolgare:PreposizioneVolgareDiSpecificazione", + "Di modo": "TipoComplementoIPreposizioneVolgare:PreposizioneVolgareDiModo", + "Di mezzo": "TipoComplementoIPreposizioneVolgare:PreposizioneVolgareDiMezzo", + "Di compagnia": "TipoComplementoIPreposizioneVolgare:PreposizioneVolgareDiCompagnia", + "Di unione": "TipoComplementoIPreposizioneVolgare:PreposizioneVolgareDiUnione", + "Di allontanamento-separazione": "TipoComplementoIPreposizioneVolgare:PreposizioneVolgareDiAllontanamentoSeparazione", + "Di materia": "TipoComplementoIPreposizioneVolgare:PreposizioneVolgareDiMateria" + }, + "Complemento_(II)": { + "Di limitazione": "TipoComplementoIIPreposizioneVolgare:PreposizioneVolgareDiLimitazione", + "Di qualità": "TipoComplementoIIPreposizioneVolgare:PreposizioneVolgareDiQualità", + "Di causa": "TipoComplementoIIPreposizioneVolgare:PreposizioneVolgareDiCausa", + "Di agente": "TipoComplementoIIPreposizioneVolgare:PreposizioneVolgareDiAgente", + "Di causa efficiente": "TipoComplementoIIPreposizioneVolgare:PreposizioneVolgareDiCausaEfficiente", + "Di fine o scopo": "TipoComplementoIIPreposizioneVolgare:PreposizioneVolgareDiFineScopo", + "Di paragone": "TipoComplementoIIPreposizioneVolgare:PreposizioneVolgareDiParagone", + "Di argomento": "TipoComplementoIIPreposizioneVolgare:PreposizioneVolgareDiArgomento", + "Distributivo": "TipoComplementoIIPreposizioneVolgare:PreposizioneVolgareDistributivo", + "Di sostituzione": "TipoComplementoIIPreposizioneVolgare:PreposizioneVolgareDiSostituzione", + "Di estensione": "TipoComplementoIIPreposizioneVolgare:PreposizioneVolgareDiEstensione", + "Di rapporto": "TipoComplementoIIPreposizioneVolgare:PreposizioneVolgareDiRapporto", + "Di esclusione": "TipoComplementoIIPreposizioneVolgare:PreposizioneVolgareDiEsclusione", + "Di peso": "TipoComplementoIIPreposizioneVolgare:PreposizioneVolgareDiPeso", + "Di quantità": "TipoComplementoIIPreposizioneVolgare:PreposizioneVolgareDiQuantità", + "Di colpa": "TipoComplementoIIPreposizioneVolgare:PreposizioneVolgareDiColpa", + "Di denominazione": "TipoComplementoIIPreposizioneVolgare:PreposizioneVolgareDiDenominazione", + "partitivo": "TipoComplementoIIPreposizioneVolgare:PreposizioneVolgarePartitivo", + "Di abbondanza-privazione": "TipoComplementoIIPreposizioneVolgare:PreposizioneVolgareDiAbbondanzaPrivazione", + "Di origine-provenienza": "TipoComplementoIIPreposizioneVolgare:PreposizioneVolgareDiOrigineProvenienza", + "Concessivo": "TipoComplementoIIPreposizioneVolgare:PreposizioneVolgareConcessivo", + "Di effetto": "TipoComplementoIIPreposizioneVolgare:PreposizioneVolgareDiEffetto", + "Di pena": "TipoComplementoIIPreposizioneVolgare:PreposizioneVolgareDiPena", + "Simmetrico": "TipoComplementoIIPreposizioneVolgare:PreposizioneVolgareSimmetrico", + "Indiretto esperiente": "TipoComplementoIIPreposizioneVolgare:PreposizioneVolgareIndirettoEsperiente", + "Indiretto dativo": "TipoComplementoIIPreposizioneVolgare:PreposizioneVolgareIndirettoDativo", + "Indiretto oggetto": "TipoComplementoIIPreposizioneVolgare:PreposizioneVolgareIndirettoOggetto", + "Indiretto possessore": "TipoComplementoIIPreposizioneVolgare:PreposizioneVolgareIndirettoPossessore", + "Indiretto benefattivo": "TipoComplementoIIPreposizioneVolgare:PreposizioneVolgareIndirettoBenefattivo" + } + }, + + "congiunzionevolgare": { + "Coo_sub": { + "Coordinativa": "TipoCooSubCongiunzioneVolgare:CongiunzioneVolgareCoordinativa", + "Subordinativa": "TipoCooSubCongiunzioneVolgare:CongiunzioneVolgareSubordinativa" + }, + "Tipo": { + "Semplice": "TipoDellaCongiunzioneVolgare:CongiunzioneVolgareSemplice", + "Composta": "TipoDellaCongiunzioneVolgare:CongiunzioneVolgareComposta", + "Locuzione": "TipoDellaCongiunzioneVolgare:CongiunzioneVolgareLocuzione", + "Locuzione separata": "TipoDellaCongiunzioneVolgare:CongiunzioneVolgareLocuzioneSeparata" + }, + "Coord_tipo": { + "Copulativa": "TipoDellaCoordinativaCongiunzioneVolgare:CongiunzioneVolgareCopulativa", + "Disgiuntiva": "TipoDellaCoordinativaCongiunzioneVolgare:CongiunzioneVolgareDisgiuntiva", + "Avversativa": "TipoDellaCoordinativaCongiunzioneVolgare:CongiunzioneVolgareAvversativa", + "Esplicativa": "TipoDellaCoordinativaCongiunzioneVolgare:CongiunzioneVolgareEsplicativa", + "Conclusiva": "TipoDellaCoordinativaCongiunzioneVolgare:CongiunzioneVolgareConclusiva", + "Correlativa": "TipoDellaCoordinativaCongiunzioneVolgare:CongiunzioneVolgareCorrelativa" + }, + "Subord_tipo": { + "Soggettiva": "TipoDellaSubordinativaCongiunzioneVolgare:CongiunzioneVolgareSoggettiva", + "Oggettiva": "TipoDellaSubordinativaCongiunzioneVolgare:CongiunzioneVolgareOggettiva", + "Dichiarativa": "TipoDellaSubordinativaCongiunzioneVolgare:CongiunzioneVolgareDichiarativa", + "Completiva obliqua": "TipoDellaSubordinativaCongiunzioneVolgare:CongiunzioneVolgareCompletivaObliqua", + "Interrogativa": "TipoDellaSubordinativaCongiunzioneVolgare:CongiunzioneVolgareInterrogativa", + "Finali": "TipoDellaSubordinativaCongiunzioneVolgare:CongiunzioneVolgareFinali", + "Causali": "TipoDellaSubordinativaCongiunzioneVolgare:CongiunzioneVolgareCausali", + "Concessiva": "TipoDellaSubordinativaCongiunzioneVolgare:CongiunzioneVolgareConcessiva", + "Consecutiva": "TipoDellaSubordinativaCongiunzioneVolgare:CongiunzioneVolgareConsecutiva", + "Temporale": "TipoDellaSubordinativaCongiunzioneVolgare:CongiunzioneVolgareTemporale", + "Modale": "TipoDellaSubordinativaCongiunzioneVolgare:CongiunzioneVolgareModale", + "Eccettuativa": "TipoDellaSubordinativaCongiunzioneVolgare:CongiunzioneVolgareEccettuativa", + "Comparativa": "TipoDellaSubordinativaCongiunzioneVolgare:CongiunzioneVolgareComparativa", + "Condizionale": "TipoDellaSubordinativaCongiunzioneVolgare:CongiunzioneVolgareCondizionale", + "Esclusiva": "TipoDellaSubordinativaCongiunzioneVolgare:CongiunzioneVolgareEsclusiva", + "Limitativa": "TipoDellaSubordinativaCongiunzioneVolgare:CongiunzioneVolgareLimitativa" + } + }, + + "onomasticavolgare": { + "Tipo": { + "Nome proprio": "TipoDellOnomasticaVolgare:NomeProprio", "Nome proprio separato": "TipoDellOnomasticaVolgare:NomeProprioSeparato", + "Titolo": "TipoDellOnomasticaVolgare:Titolo" + } + }, + + "citazionevolgare": { + "Tipo": { + "Latina": "TipoDellaCitazioneVolgare:CitazioneLatina", + "Provenzale": "TipoDellaCitazioneVolgare:CitazioneProvenzale", + "Francese": "TipoDellaCitazioneVolgare:CitazioneFrancese", + "Spagnola": "TipoDellaCitazioneVolgare:CitazioneSpagnola", + "Ebraica": "TipoDellaCitazioneVolgare:CitazioneEbraica", + "Greca": "TipoDellaCitazioneVolgare:CitazioneGreca" + } + + } +} + +/* +* +* SPARQL statements +* +*/ +data21 = `{"verbovolgare": {"subject": {"termType": "Variable", "value":"form"}, "predicate": {"termType":"NamedNode", "value": "http://www.w3.org/1999/02/22-rdf-syntax-ns#type"}, "object": {"termType": "NamedNode", "value": "https://dantenetwork.it/ontology/orl/current/FormaVerboVolgare"}}, + "sostantivovolgare": {"subject": {"termType": "Variable", "value":"form"}, "predicate": {"termType":"NamedNode", "value": "http://www.w3.org/1999/02/22-rdf-syntax-ns#type"}, "object": {"termType": "NamedNode", "value": "https://dantenetwork.it/ontology/orl/current/FormaSostantivoVolgare"}}, + "aggettivovolgare": {"subject": {"termType": "Variable", "value":"form"}, "predicate": {"termType":"NamedNode", "value": "http://www.w3.org/1999/02/22-rdf-syntax-ns#type"}, "object": {"termType": "NamedNode", "value": "https://dantenetwork.it/ontology/orl/current/FormaAggettivoVolgare"}}, + "avverbiovolgare": {"subject": {"termType": "Variable", "value":"form"}, "predicate": {"termType":"NamedNode", "value": "http://www.w3.org/1999/02/22-rdf-syntax-ns#type"}, "object": {"termType": "NamedNode", "value": "https://dantenetwork.it/ontology/orl/current/FormaAvverbioVolgare"}}, + "pronomevolgare": {"subject": {"termType": "Variable", "value":"form"}, "predicate": {"termType":"NamedNode", "value": "http://www.w3.org/1999/02/22-rdf-syntax-ns#type"}, "object": {"termType": "NamedNode", "value": "https://dantenetwork.it/ontology/orl/current/FormaPronomeVolgare"}}, + "congiunzionevolgare": {"subject": {"termType": "Variable", "value":"form"}, "predicate": {"termType":"NamedNode", "value": "http://www.w3.org/1999/02/22-rdf-syntax-ns#type"}, "object": {"termType": "NamedNode", "value": "https://dantenetwork.it/ontology/orl/current/FormaCongiunzioneVolgare"}}, + "articolovolgare": {"subject": {"termType": "Variable", "value":"form"}, "predicate": {"termType":"NamedNode", "value": "http://www.w3.org/1999/02/22-rdf-syntax-ns#type"}, "object": {"termType": "NamedNode", "value": "https://dantenetwork.it/ontology/orl/current/FormaArticoloVolgare"}}, + "preposizionevolgare": {"subject": {"termType": "Variable", "value":"form"}, "predicate": {"termType":"NamedNode", "value": "http://www.w3.org/1999/02/22-rdf-syntax-ns#type"}, "object": {"termType": "NamedNode", "value": "https://dantenetwork.it/ontology/orl/current/FormaPreposizioneVolgare"}}, + "interiezionevolgare": {"subject": {"termType": "Variable", "value":"form"}, "predicate": {"termType":"NamedNode", "value": "http://www.w3.org/1999/02/22-rdf-syntax-ns#type"}, "object": {"termType": "NamedNode", "value": "https://dantenetwork.it/ontology/orl/current/FormaInteriezioneVolgare"}}, + "onomasticavolgare": {"subject": {"termType": "Variable", "value":"form"}, "predicate": {"termType":"NamedNode", "value": "http://www.w3.org/1999/02/22-rdf-syntax-ns#type"}, "object": {"termType": "NamedNode", "value": "https://dantenetwork.it/ontology/orl/current/FormaOnomasticaVolgare"}}, + "citazionevolgare": {"subject": {"termType": "Variable", "value":"form"}, "predicate": {"termType":"NamedNode", "value": "http://www.w3.org/1999/02/22-rdf-syntax-ns#type"}, "object": {"termType": "NamedNode", "value": "https://dantenetwork.it/ontology/orl/current/FormaCitazioneVolgare"}}, + "locuzionevolgare": {"subject": {"termType": "Variable", "value":"form"}, "predicate": {"termType":"NamedNode", "value": "http://www.w3.org/1999/02/22-rdf-syntax-ns#type"}, "object": {"termType": "NamedNode", "value": "https://dantenetwork.it/ontology/orl/current/FormaLocuzioneVolgare"}} + } + ` + +writtenrepresentation = `{"subject": {"termType": "Variable", "value":"form"}, "predicate": {"termType":"NamedNode", "value": "http://www.w3.org/ns/lemon/ontolex#writtenRep"}, "object": {"termType": "Variable", "value": "Rappresentazione"}}` + + +var morphgroup = `{"type": "group", + "patterns": [{"type": "bgp", + "triples": [ + {"subject": {"termType": "Variable","value": "form"}, + "predicate": {"termType": "NamedNode", "value": "http://www.w3.org/ns/lemon/ontolex#writtenRep"}, + "object": {"termType": "Variable","value": "Rappresentazione"}}, + {"subject": {"termType": "Variable","value": "lent"}, + "predicate": {"termType": "NamedNode","value": "http://www.w3.org/ns/lemon/ontolex#lexicalForm"}, + "object": {"termType": "Variable", "value": "form"}}, + {"subject": {"termType": "Variable","value": "lent"}, + "predicate": {"termType": "NamedNode","value": "http://www.w3.org/ns/lemon/ontolex#canonicalForm"}, + "object": {"termType": "Variable","value": "cf"}}, + {"subject": {"termType": "Variable","value": "cf"}, + "predicate": {"termType": "NamedNode","value": "http://www.w3.org/ns/lemon/ontolex#writtenRep"}, + "object": {"termType": "Variable","value": "lm"}}, + {"subject": {"termType": "Variable","value": "fa"}, + "predicate": {"termType": "NamedNode","value": "https://dantenetwork.it/ontology/olires/current/occurrenceOf"}, + "object": {"termType": "Variable","value": "form"}}, + {"subject": {"termType": "Variable","value": "fa"}, + "predicate": {"termType": "NamedNode","value": "https://dantenetwork.it/ontology/olires/current/OccursInRegion"}, + "object": {"termType": "Variable", "value": "reg"}}, + {"subject": {"termType": "Variable","value": "reg"}, + "predicate": {"termType": "NamedNode","value": "https://dantenetwork.it/ontology/olires/current/fragmentRegionFrom"}, + "object": {"termType": "Variable","value": "pos1"}} + ] + } + ] + } +` +var syntgroup = ` { + "type": "group", + "patterns": [ + { + "type": "bgp", + "triples": [ + {"subject": {"termType": "Variable","value": "clocc"}, + "predicate": {"termType": "NamedNode","value": "https://dantenetwork.it/ontology/olires/current/occurrenceOf"}, + "object": {"termType": "Variable","value": "cl"}}, + {"subject": {"termType": "Variable","value": "clocc"}, + "predicate": {"termType": "NamedNode","value": "http://erlangen-crm.org/current/P148_has_component"}, + "object": {"termType": "Variable","value": "fa"}}, + {"subject": {"termType": "Variable","value": "clocc"}, + "predicate": {"termType": "NamedNode","value": "https://dantenetwork.it/ontology/olires/current/occursInRegion"}, + "object": {"termType": "Variable","value": "frag"}}, + {"subject": {"termType": "Variable","value": "sentence"}, + "predicate": {"termType": "NamedNode","value": "http://www.w3.org/1999/02/22-rdf-syntax-ns#type"}, + "object": {"termType": "NamedNode","value": "https://dantenetwork.it/ontology/syntit/current/Sentence"}}, + {"subject": {"termType": "Variable","value": "sentence"}, + "predicate": {"termType": "NamedNode","value": "http://erlangen-crm.org/current/P148i_is_component_of"}, + "object": {"termType": "Variable","value": "canto"}}, + {"subject": {"termType": "Variable","value": "sentence"}, + "predicate": {"termType": "NamedNode","value": "https://dantenetwork.it/ontology/syntit/current/hasSyntacticalComponent"}, + "object": {"termType": "Variable","value": "cl"}}, + {"subject": {"termType": "Variable","value": "cl"}, + "predicate": {"termType": "NamedNode","value": "https://dantenetwork.it/ontology/syntit/current/hasClauseType"}, + "object": {"termType": "Variable","value": "clatype"}}, + {"subject": {"termType": "Variable","value": "cl"}, + "predicate": {"termType": "NamedNode","value": "http://erlangen-crm.org/current/P190_has_symbolic_content"}, + "object": {"termType": "Variable","value": "cltext"}}, + {"subject": {"termType": "Variable","value": "cl"}, + "predicate": {"termType": "NamedNode","value": "https://dantenetwork.it/ontology/syntit/current/hasClauseFunction"}, + "object": {"termType": "Variable","value": "clafunction"}}, + {"subject": {"termType": "Variable","value": "frag"}, + "predicate": {"termType": "NamedNode","value": "https://dantenetwork.it/ontology/olires/current/fragmentRegionFrom"}, + "object": {"termType": "Variable","value": "clfr"}}, + {"subject": {"termType": "Variable","value": "frag"}, + "predicate": {"termType": "NamedNode","value": "https://dantenetwork.it/ontology/olires/current/fragmentRegionTo"}, + "object": {"termType": "Variable","value": "clto"}} + ] + } + ] + } + +` +/* +* +*Tipi sintattici +* +*/ + +var funzione_clausola = +{ + "princ": "hasClauseFunction:MainClause", + "subord i": "hasClauseFunction:SubordinateClauseI", + "subord ii": "hasClauseFunction:SubordinateClauseII", + "subord iii": "hasClauseFunction:SubordinateClauseIII", + "subord iv": "hasClauseFunction:SubordinateClauseIV", + "subord v": "hasClauseFunction:SubordinateClauseV", + "subord vi": "hasClauseFunction:SubordinateClauseVI", + "subord vii": "hasClauseFunction:SubordinateClauseVII", + "coord": "hasClauseFunction:CoordinateClause", + "coord i": "hasClauseFunction:CoordinateClauseI", + "coord ii": "hasClauseFunction:CoordinateClauseII", + "coord iii": "hasClauseFunction:CoordinateClauseIII", + "coord iv": "hasClauseFunction:CoordinateClauseIV", + "coord v": "hasClauseFunction:CoordinateClauseV", + "pcoord": "hasClauseFunction:ParentheticalCoordinateClause", + "parent": "hasClauseFunction:ParentethicalClause", + "coord 0": "hasClauseFunction:PseudoCoordinateClause" +} + +//da completare + +var listaMacroTipiConSubTipo = ['Concessiva', 'Comparativa', 'Ipotetica', 'Interrogativa', 'Iussiva', 'Ottativa', 'Avversativa', 'Relativa'] + +var macrotipi_sint = +{ + "macro avv": "hasClauseType:Avversativa", + "avv": "hasClauseType:Avversativa", + "macro caus": "hasClauseType:Causale", + "macro compar": "hasClauseType:Comparativa", + "macro conces": "hasClauseType:Concessiva", + "macro consec": "hasClauseType:Consecutiva", + "macro dich": "hasClauseType:Dichiarativa", + "macro eccettu": "hasClauseType:Eccettuativa", + "macro epesege": "hasClauseType:Epesegetica", + "macro escl": "hasClauseType:Esclamativa", + "macro esclu": "hasClauseType:Esclusiva", + "macro finale": "hasClauseType:Finale", + "macro inter princ": "hasClauseType:Interrogativa", + "macro inter sub": "hasClauseType:Interrogativa", + "macro ipotet": "hasClauseType:Ipotetica", + "macro iussi": "hasClauseType:Iussiva", + "macro limitat": "hasClauseType:Limitativa", + "macro maniera": "hasClauseType:DiManiera", + "macro modale": "hasClauseType:Modale", + "macro obliqua": "hasClauseType:Obliqua", + "macro oggettiva": "hasClauseType:Oggettiva", + "macro otta": "hasClauseType:Ottativa", + //"macro pare mod": "hasClauseType:ParenteticaModalizzante", + //"macro pare sub": "hasClauseType:ParenteticaConValoreDiSubordinata", + "macro pare mod": "hasClauseType:Modalizzante;hasClauseFunction:ParentethicalClause", + "macro pare sub": "hasClauseType:Subordinata;hasClauseFunction:ParentethicalClause", + "macro pred": "hasClauseType:Predicativa", + //"macro pseudo": "hasClauseType:Pseudocoordinata", + "macro pseudo": "hasClauseFunction:ParentheticalCoordinateClause", + "macro rel": "hasClauseType:Relativa", + "macro sog": "hasClauseType:Soggettiva", + "macro strum": "hasClauseType:Strumentale", + //"macro sub": "hasClauseType:SubordinataConFunzioneDiRipresa", + "macro sub": "hasClauseFunction:SubordinateClauseI;hasClauseType:FunzioneDiRipresa", + "macro temp": "hasClauseType:Temporale" +} + +var tipi_sint = +{ + "avv caus": "hasClauseType:CoordinataAvversativaCausale", + "avv comp ug": "hasClauseType:CoordinataAvversativaComparativaDiUguaglianza", + "avv cons antec": "hasClauseType:CoordinataAvversativaConsecutivaConAntecedente", + "avv dich": "hasClauseType:CoordinataAvversativaDichiarativa", + "avv fin": "hasClauseType:CoordinataAvversativaFinale", + "avv int x": "hasClauseType:CoordinataAvversativaInterrogativaDiTipoX", + "avv int x ret": "hasClauseType:CoordinataAvversativaInterrogativaDiTipoXRetorica", + "avv ipo caus": "hasClauseType:CoordinataAvversativaIpoteticaConValoreCausale", + "avv iuss dir": "hasClauseType:CoordinataAvversativaIussivaDiretta", + "avv iuss indir": "hasClauseType:CoordinataAvversativaIussivaIndiretta", + "avv modaliz ott intr": "hasClauseType:CoordinataAvversativaModalizzanteOttativaConIntroduttore", + "avv ogg": "hasClauseType:CoordinataAvversativaOggettiva", + "avv ogg perc": "hasClauseType:CoordinataAvversativaOggettiva", + "avv rel app": "hasClauseType:CoordinataAvversativaRelativaAppositiva", + "avv rel app comp ug": "hasClauseType:CoordinataAvversativaRelativaAppositivaInConstruttoComparativo", + "avv rel app cons antec": "hasClauseType:CoordinataAvversativaRelativaAppositivaConValoreConsecutivo", + "avv rel giust": "hasClauseType:CoordinataAvversativaRelativaGiustapposta", + "avv rel ind": "hasClauseType:CoordinataAvversativaRelativaIndipendente", + "avv rel ind temp": "hasClauseType:CoordinataAvversativaRelativaIndipendenteTemporale", + "avv rel restr": "hasClauseType:CoordinataAvversativaRelativaRestrittiva", + "avv rel restr comp ug": "hasClauseType:CoordinataAvversativaRelativaRestrittivaInCostruttoComparativo", + "avv sogg": "hasClauseType:CoordinataAvversativaSoggettiva", + "avv temp": "hasClauseType:CoordinataAvversativaTemporale", + "comp disug": "hasClauseType:ComparativaDiDisuguaglianza", + "comp disug ipo": "hasClauseType:ComparativaDiDisuguaglianzaConValoreIpotetico", + "comp fin": "hasClauseType:ComparativaConValoreFinale", + "comp ipo": "hasClauseType:ComparativaConValoreIpotetico", + "comp lim": "hasClauseType:ComparativaConValoreLimitativo", + "comp mod": "hasClauseType:ComparativaConValoreModale", + "comp temp": "hasClauseType:ComparativaConValoreTemporale", + "comp ug": "hasClauseType:ComparativaDiUguaglianza", + "comp ug rel ind temp": "hasClauseType:ComparativaDiUguaglianzaConValoreDiRelativaIndipendenteTemporale", + "conc acond": "hasClauseType:ConcessivaAcondizionale", + "conc cond": "hasClauseType:ConcessivaCondizionale", + "conc fatt": "hasClauseType:ConcessivaFattuale", + "cong asind comp ug": "hasClauseType:CoordinataAsindeticaComparativaDiUguaglianza", + "cong asind cons antec": "hasClauseType:CoordinataAsindeticaConsecutivaConAntecedente", + "cong asind dich": "hasClauseType:CoordinataAsindeticaDichiarativa", + "cong asind epes": "hasClauseType:CoordinataAsindeticaEpesegetica", + "cong asind esclam": "hasClauseType:CoordinataAsindeticaEsclamativa", + "cong asind fin": "hasClauseType:CoordinataAsindeticaFinale", + "cong asind int altern": "hasClauseType:CoordinataAsindeticaInterrogativaAlternativa", + "cong asind int altern ret": "hasClauseType:CoordinataAsindeticaInterrogativaAlternativaRetorica", + "cong asind int disg": "hasClauseType:CoordinataAsindeticaInterrogativaDisgiuntiva", + "cong asind int x": "hasClauseType:CoordinataAsindeticaInterrogativaDiTipoX", + "cong asind int x ret": "hasClauseType:CoordinataAsindeticaInterrogativaDiTipoXRetorica", + "cong asind ipo": "hasClauseType:CoordinataAsindeticaIpotetica", + "cong asind iuss dir": "hasClauseType:CoordinataAsindeticaIussivaDiretta", + "cong asind iuss indir": "hasClauseType:CoordinataAsindeticaIussivaIndiretta", + "cong asind man": "hasClauseType:CoordinataAsindeticaDiManiera", + "cong asind ogg": "hasClauseType:CoordinataAsindeticaOggettiva", + "cong asind ogg perc": "hasClauseType:CoordinataAsindeticaOggettiva", + "cong asind ott intr": "hasClauseType:CoordinataAsindeticaOttativaConIntroduttore", + "cong asind ott libera": "hasClauseType:CoordinataAsindeticaOttativaLibera", + "cong asind rel app": "hasClauseType:CoordinataAsindeticaRelativaAppositiva", + "cong asind rel app comp disug": "hasClauseType:CoordinataAsindeticaRelativaAppositivaInConstruttoComparativo", + "cong asind rel app giust": "hasClauseType:CoordinataAsindeticaRelativaGiustapposta", + "cong asind rel ind": "hasClauseType:CoordinataAsindeticaRelativaIndipendente", + "cong asind rel ind temp caus": "hasClauseType:CoordinataAsindeticaRelativaIndipendenteConValoreTemporaleCausale", + "cong asind rel restr": "hasClauseType:CoordinataAsindeticaRelativaRestrittiva", + "cong asind rel restr comp ug": "hasClauseType:CoordinataAsindeticaRelativaRestrittivaInConstruttoComparativo", + "cong asind sogg soll": "hasClauseType:CoordinataAsindeticaSoggettivaASollevamento", + "cong asind subord": "hasClauseType:CoordinataAsindeticaSubordinata", + "cong asind temp": "hasClauseType:CoordinataAsindeticaTemporale", + "cong caus": "hasClauseType:CoordinataCongiuntivaCausale", + "cong comp disug": "hasClauseType:CoordinataCongiuntivaComparativaDiDisuguaglianza", + "cong comp ipo": "hasClauseType:CoordinataCongiuntivaComparativaConValoreIpotetico", + "cong comp lim": "hasClauseType:CoordinataCongiuntivaComparativaConValoreLimitativo", + "cong comp mod": "hasClauseType:CoordinataCongiuntivaComparativaConValoreModale", + "cong comp ug": "hasClauseType:CoordinataCongiuntivaComparativaDiUguaglianza", + "cong conc cond": "hasClauseType:CoordinataCongiuntivaConcessivaCondizionale", + "cong conc fatt": "hasClauseType:CoordinataCongiuntivaConcessivaFattuale", + "cong concl cons antec": "hasClauseType:CoordinataConclusivaConsecutivaConAntecedente", + "cong concl dich": "hasClauseType:CoordinataConclusivaDichiarativa", + "cong concl dich ill": "hasClauseType:CoordinataConclusivaDichiarativaIllocutiva", + "cong concl iuss dir": "hasClauseType:CoordinataConclusivaIussivaDiretta", + "cong concl iuss dir perifr": "hasClauseType:CoordinataConclusivaIussivaDirettaPerifrastica", + "cong concl iuss indir": "hasClauseType:CoordinataConclusivaIussivaIndiretta", + "cong cons antec": "hasClauseType:CoordinataCongiuntivaConsecutivaConAntecedente", + "cong cons antec epes": "hasClauseType:CoordinataCongiuntivaConsecutivaConAntecedenteEpisegetica", + "cong cons antec fin": "hasClauseType:CoordinataCongiuntivaConsecutivaConAntecedenteConValoreFinale", + "cong cons caus": "hasClauseType:CoordinataConsecutivaCausale", + "cong cons dich": "hasClauseType:CoordinataConsecutivaDichiarativa", + "cong cons ell": "hasClauseType:CoordinataCongiuntivaConsecutivaEllittica", + "cong cons libera": "hasClauseType:CoordinataCongiuntivaConsecutivaLibera", + "cong cons libera fin": "hasClauseType:CoordinataCongiuntivaConsecutivaLiberaConValoreFinale", + "cong cons post": "hasClauseType:CoordinataCongiuntivaConsecutivaPosposta", + "cong corr dich": "hasClauseType:CoordinataCorrelativaDichiarativa", + "cong corr fin": "hasClauseType:CoordinataCorrelativaFinale", + "cong corr lim": "hasClauseType:CoordinataCorrelativaLimitativa", + "cong corr sogg infinitoprep": "hasClauseType:CoordinataCorrelativaSoggettivaAInfinitoPreposizionale", + "cong dich": "hasClauseType:CoordinataCongiuntivaDichiarativa", + "cong dich ill": "hasClauseType:CoordinataCongiuntivaDichiarativaIllocutiva", + "cong eccett": "hasClauseType:CoordinataCongiuntivaEccettuativa", + "cong epes": "hasClauseType:CoordinataCongiuntivaEpesegetica", + "cong esclam": "hasClauseType:CoordinataCongiuntivaEsclamativa", + "cong esclus": "hasClauseType:CoordinataCongiuntivaEsclusiva", + "cong espl dich": "hasClauseType:CoordinataEsplicativaDichiarativa", + "cong espl obl": "hasClauseType:CoordinataEsplicativaObliqua", + "cong espl ogg": "hasClauseType:CoordinataEsplicativaOggettiva", + "cong espl rel app antec": "hasClauseType:CoordinataEsplicativaRelativaAppositivaConAntecedente", + "cong espl rel ind mod": "hasClauseType:CoordinataEsplicativaRelativaIndipendenteConValoreModale", + "cong fin": "hasClauseType:CoordinataCongiuntivaFinale", + "cong int altern": "hasClauseType:CoordinataCongiuntivaInterrogativaAlternativa", + "cong int x": "hasClauseType:CoordinataCongiuntivaInterrogativaDiTipoX", + "cong int x ret": "hasClauseType:CoordinataCongiuntivaInterrogativaDiTipoXRetorica", + "cong ipo": "hasClauseType:CoordinataCongiuntivaIpotetica", + "cong ipo caus": "hasClauseType:CoordinataCongiuntivaIpoteticaConValoreCausale", + "cong ipo sogg": "hasClauseType:CoordinataCongiuntivaIpoteticaSoggettiva", + "cong iuss dir": "hasClauseType:CoordinataCongiuntivaIussivaDiretta", + "cong iuss indir": "hasClauseType:CoordinataCongiuntivaIussivaIndiretta", + "cong lim": "hasClauseType:CoordinataCongiuntivaLimitativa", + "cong man": "hasClauseType:CoordinataCongiuntivaDiManiera", + "cong modaliz ott intr": "hasClauseType:CoordinataCongiuntivaModalizzanteOttativaConIntroduttore", + "cong obl": "hasClauseType:CoordinataCongiuntivaObliqua", + "cong ogg": "hasClauseType:CoordinataCongiuntivaOggettiva", + "cong ogg perc": "hasClauseType:CoordinataCongiuntivaOggettiva", + "cong ott libera": "hasClauseType:CoordinataCongiuntivaLibera", + "cong rel app": "hasClauseType:CoordinataCongiuntivaRelativaAppositiva", + "cong rel app comp disug": "hasClauseType:CoordinataCongiuntivaRelativaAppositivaInCostruttoComparativoDiDisuguaglianza", + "cong rel app comp ug": "hasClauseType:CoordinataCongiuntivaRelativaAppositivaInCostruttoComparativoDiUguaglianza", + "cong rel app cons": "hasClauseType:CoordinataCongiuntivaRelativaAppositivaConValoreConsecutivo", + "cong rel app epes": "hasClauseType:CoordinataCongiuntivaRelativaAppositivaConValoreDiEpisegetica", + "cong rel app fin": "hasClauseType:CoordinataCongiuntivaRelativaAppositivaConValoreFinale", + "cong rel app giust": "hasClauseType:CoordinataCongiuntivaRelativaGiustapposta", + "cong rel app giust caus": "hasClauseType:CoordinataCongiuntivaRelativaGiustappostaConValoreCausale", + "cong rel app temp": "hasClauseType:CoordinataCongiuntivaRelativaAppositivaConValoreTemporale", + "cong rel impl": "hasClauseType:CoordinataCongiuntivaRelativaImplicita", + "cong rel impl lim": "hasClauseType:CoordinataCongiuntivaRelativaImplicitaConValoreLimitativo", + "cong rel ind": "hasClauseType:CoordinataCongiuntivaRelativaIndipendente", + "cong rel ind acond": "hasClauseType:CoordinataCongiuntivaRelativaIndipendenteAcondizionale", + "cong rel ind ipo": "hasClauseType:CoordinataCongiuntivaRelativaIndipendenteConValoreIpotetico", + "cong rel ind mod": "hasClauseType:CoordinataCongiuntivaRelativaIndipendenteConValoreModale", + "cong rel ind mod comp ug": "hasClauseType:CoordinataCongiuntivaRelativaIndipendenteInCostruttoComparativoModale", + "cong rel ind temp": "hasClauseType:CoordinataCongiuntivaRelativaIndipendenteTemporale", + "cong rel pseudo": "hasClauseType:CoordinataCongiuntivaPseudoRelativa", + "cong rel restr": "hasClauseType:CoordinataCongiuntivaRelativaRestrittiva", + "cong rel restr caus": "hasClauseType:CoordinataCongiuntivaRelativaRestrittivaConValoreCausale", + "cong rel restr comp": "hasClauseType:CoordinataCongiuntivaRelativaRestrittivaInCostruttoComparativo", + "cong rel restr comp ug": "hasClauseType:CoordinataCongiuntivaRelativaRestrittivaInCostruttoComparativoDiUguaglianza", + "cong rel restr cons": "hasClauseType:CoordinataCongiuntivaRelativaRestrittivaConValoreConsecutivo", + "cong rel restr temp": "hasClauseType:CoordinataCongiuntivaRelativaRestrittivaTemporale", + "cong rip": "hasClauseType:CoordinataCongiuntivaConFunzioneDiRipresa", + "cong sogg": "hasClauseType:CoordinataCongiuntivaSoggettiva", + "cong spec": "hasClauseType:CoordinataCongiuntivaSpecificativa", + "cong strum": "hasClauseType:CoordinataCongiuntivaStrumentale", + "cong subord": "hasClauseType:CoordinataCongiuntivaSubordinata", + "cong temp": "hasClauseType:CoordinataCongiuntivaTemporale", + "cong temp caus": "hasClauseType:CoordinataCongiuntivaTemporaleConValoreCausale", + "cons antec": "hasClauseType:ConsecutivaConAntecedente", + "cons antec epes": "hasClauseType:ConsecutivaConAntecedenteEpesegetica", + "cons antec fin": "hasClauseType:ConsecutivaConAntecedenteConValoreFinale", + "cons antec temp": "hasClauseType:ConsecutivaConAntecedenteConValoreTemporale", + "cons ell": "hasClauseType:ConsecutivaEllittica", + "cons libera": "hasClauseType:ConsecutivaLibera", + "cons libera fin": "hasClauseType:ConsecutivaLiberaConValoreFinale", + "cons post": "hasClauseType:ConsecutivaPosposta", + "dich": "hasClauseType:Dichiarativa", + "dich ill": "hasClauseType:DichiarativaIllocutiva", + "disg comp disug temp": "hasClauseType:CoordinataDisgiuntivaComparativaDiDisuguaglianzaConValoreTemporale", + "disg conc acond": "hasClauseType:CoordinataDisgiuntivaConcessivaAcondizionale", + "disg conc cond": "hasClauseType:CoordinataDisgiuntivaConcessivaCondizionale", + "disg cons libera": "hasClauseType:CoordinataDisgiuntivaConsecutivaLibera", + "disg corr dich": "hasClauseType:CoordinataDisgiuntivaCorrelativaDichiarativa", + "disg dich": "hasClauseType:CoordinataDisgiuntivaDichiarativa", + "disg epes": "hasClauseType:CoordinataDisgiuntivaEpesegetica", + "disg esclus": "hasClauseType:CoordinataDisgiuntivaEsclusiva", + "disg int altern": "hasClauseType:CoordinataDisgiuntivaInterrogativaAlternativa", + "disg int disg": "hasClauseType:CoordinataDisgiuntivaInterrogativaDisgiuntiva", + "disg int x": "hasClauseType:CoordinataDisgiuntivaInterrogativaDiTipoX", + "disg ipo": "hasClauseType:CoordinataDisgiuntivaIpotetica", + "disg lim": "hasClauseType:CoordinataDisgiuntivaLimitativa", + "disg man": "hasClauseType:CoordinataDisgiuntivaDiManiera", + "disg obl": "hasClauseType:CoordinataDisgiuntivaObliqua", + "disg ogg": "hasClauseType:CoordinataDisgiuntivaOggettiva", + "disg rel ind": "hasClauseType:CoordinataDisgiuntivaRelativaIndipendente", + "disg rel ind acond": "hasClauseType:CoordinataDisgiuntivaRelativaIndipendenteAcondizionale", + "disg rel ind temp": "hasClauseType:CoordinataDisgiuntivaRelativaIndipendenteTemporale", + "disg rel restr": "hasClauseType:CoordinataDisgiuntivaRestrittiva", + "disg rel restr cons": "hasClauseType:CoordinataDisgiuntivaRestrittivaConValoreConsecutivo", + "disg sogg": "hasClauseType:CoordinataDisgiuntivaSoggettiva", + "disg temp": "hasClauseType:CoordinataDisgiuntivaTemporale", + "eccett": "hasClauseType:Eccettuativa", + "eccett comp ug": "hasClauseType:EccettuativaConValoreDiComparativaDiUguaglianza", + "epes": "hasClauseType:Epesegetica", + "esclam": "hasClauseType:Esclamativa", + "esclus": "hasClauseType:Esclusiva", + "faltern": "hasClauseType:FalsaAlternativa", + "fcong": "hasClauseType:FalsaCongiuntiva", + "fin": "hasClauseType:Finale", + "fin ipo": "hasClauseType:FinaleConValoreIpotetico", + "fin rel giust": "hasClauseType:ConcorrenzaDelRelativoInFraseFinale", + "int altern": "hasClauseType:InterrogativaAlternativa", + "int altern ret": "hasClauseType:InterrogativaAlternativaRetorica", + "int disg": "hasClauseType:InterrogativaDisgiuntiva", + "int disg ret": "hasClauseType:InterrogativaDisgiuntivaRetorica", + "int x": "hasClauseType:InterrogativaDiTipoX", + "int x ret": "hasClauseType:InterrogativaDiTipoXRetorica", + "ipo": "hasClauseType:Ipotetica", + "ipo biaff": "hasClauseType:IpoteticaBiaffermativa", + "ipo caus": "hasClauseType:IpoteticaConValoreCausale", + "ipo eccett": "hasClauseType:IpoteticaConValoreEccettuativo", + "ipo obl": "hasClauseType:IpoteticaObliqua", + "ipo rel giust": "hasClauseType:IpoteticaRelativaGiustapposta", + "ipo sogg": "hasClauseType:IpoteticaSoggettiva", + "iuss aug": "hasClauseType:IussivaAugurativa", + "iuss dir": "hasClauseType:IussivaDiretta", + "iuss dir perifr": "hasClauseType:IussivaDirettaPerifrastica", + "iuss indir": "hasClauseType:IussivaIndiretta", + "lim": "hasClauseType:Limitativa", + "lim caus": "hasClauseType:LimitativaConValoreCausale", + "lim caus eccett": "hasClauseType:LimitativaConValoreCausaleEccettuativo", + "lim eccett": "hasClauseType:LimitativaConValoreEccettuativo", + "man": "hasClauseType:DiManiera", + "man gerundioprep": "hasClauseType:DiManieraAGerundioPreposizionale", + "man rel giust": "hasClauseType:ConcorrenzaDelRelativoInFraseDiManiera", + "mod": "hasClauseType:Modale", + "modaliz": "hasClauseType:Modalizzante", + "modaliz ott intr": "hasClauseType:ModalizzanteOttativaConIntroduttore", + "modalizz ott libera": "hasClauseType:ModalizzanteOttativaLibera", + "obl": "hasClauseType:Obliqua", + "ogg": "hasClauseType:Oggettiva", + "ogg aci": "hasClauseType:Oggettiva", + "ogg perc": "hasClauseType:Oggettiva", + "ott intr": "hasClauseType:OttativaConIntroduttore", + "ott libera": "hasClauseType:OttativaLibera", + "pred": "hasClauseType:Predicativa", + "rel app antec": "hasClauseType:RelativaAppositivaConAntecedente", + "rel app antec caus": "hasClauseType:RelativaAppositivaConAntecedenteConValoreCausale", + "rel app antec comp disug": "hasClauseType:RelativaAppositivaConAntecedenteInCostruttoComparativoDiDisuguaglianza", + "rel app antec comp ug": "hasClauseType:RelativaAppositivaConAntecedenteInCostruttoComparativoDiUguaglianza", + "rel app antec comp ug": "hasClauseType:RelativaConAntecedenteInCostruttoComparativoDiUguaglianza", + "rel app antec cons": "hasClauseType:RelativaAppositivaConAntecedenteConValoreConsecutivo", + "rel app antec eccett": "hasClauseType:RelativaAppositivaConAntecedenteInCostruttoEccettuativo", + "rel app antec fin": "hasClauseType:RelativaAppositivaConAntecedenteConValoreFinale", + "rel app antec fin cons": "hasClauseType:RelativaAppositivaConAntecedenteConValoreConsecutivoFinale", + "rel app antec giust": "hasClauseType:RelativaAppositivaConAntecedenteGiustapposta", + "rel app antec giust cons": "hasClauseType:RelativaAppositivaGiustappostaConValoreConsecutivo", + "rel app antec giust ipo": "hasClauseType:RelativaAppositivaGiustappostaConValoreIpotetico", + "rel app antec giust man": "hasClauseType:RelativaAppositivaGiustappostaConValoreDiManiera", + "rel app antec strum": "hasClauseType:RelativaAppositivaConAntecedenteConValoreStrumentale", + "rel giust": "hasClauseType:RelativaGiustapposta", + "rel impl": "hasClauseType:RelativaImplicita", + "rel impl cons": "hasClauseType:RelativaImplicitaConValoreConsecutivo", + "rel impl deon": "hasClauseType:RelativaImplicitaDeontica", + "rel impl fin": "hasClauseType:RelativaImplicitaConValoreFinale", + "rel impl lim": "hasClauseType:RelativaImplicitaConValoreLimitativo", + "rel ind": "hasClauseType:RelativaIndipendente", + "rel ind acond": "hasClauseType:RelativaIndipendenteAcondizionale", + "rel ind caus": "hasClauseType:RelativaIndipendenteInCostruttoCausale", + "rel ind comp": "hasClauseType:RelativaIndipendenteInCostruttoComparativo", + "rel ind ipo": "hasClauseType:RelativaIndipendenteConValoreIpotetico", + "rel ind mod": "hasClauseType:RelativaIndipendenteConValoreModale", + "rel ind mod comp ug": "hasClauseType:RelativaIndipendenteInCostruttoComparativoModale", + "rel ind temp": "hasClauseType:RelativaIndipendenteConValoreTemporale", + "rel ind temp acond": "hasClauseType:RelativaIndipendenteConValoreTemporaleAcondizionale", + "rel ind temp caus": "hasClauseType:RelativaIndipendenteConValoreTemporaleCausale", + "rel ind temp comp ug": "hasClauseType:RelativaIndipendenteInCostruttoComparativoDiUguaglianza", + "rel pseudo": "hasClauseType:PseudoRelativa", + "rel pseudo fin": "hasClauseType:PseudoRelativaConValoreFinale", + "rel pseudo scissa": "hasClauseType:PseudoRelativaScissa", + "rel pseudo scissa temp": "hasClauseType:PseudoRelativaScissaConValoreTemporale", + "rel restr antec": "hasClauseType:RelativaRestrittivaConAntecedente", + "rel restr antec caus": "hasClauseType:RelativaRestrittivaConAntecedenteConValoreCausale", + "rel restr antec comp disug": "hasClauseType:RelativaRestrittivaConAntecedenteInCostruttoComparativoDiDisuguaglianza", + "rel restr antec comp mod": "hasClauseType:RelativaRestrittivaConAntecedenteInCostruttoComparativoModale", + "rel restr antec comp ug": "hasClauseType:RelativaRestrittivaConAntecedenteInCostruttoComparativoDiUguaglianza", + "rel restr antec conc cond": "hasClauseType:RelativaRestrittivaConAntecedenteConValoreDiConcessivaCondizionale", + "rel restr antec conc fatt": "hasClauseType:RelativaRestrittivaConAntecedenteConValoreDiConcessivaFattuale", + "rel restr antec cons": "hasClauseType:RelativaRestrittivaConAntecedenteConValoreConsecutivo", + "rel restr antec eccett": "hasClauseType:RelativaRestrittivaConAntecedenteInCostruttoEccettuativo", + "rel restr antec fin": "hasClauseType:RelativaRestrittivaConAntecedenteConValoreFinale", + "rel restr antec ipo": "hasClauseType:RelativaRestrittivaConAntecedenteConValoreIpotetico", + "rel restr antec lim": "hasClauseType:RelativaRestrittivaConAntecedenteInCostruttoLimitativo", + "rel restr antec temp": "hasClauseType:RelativaRestrittivaConAntecedenteConValoreTemporale", + "rip": "hasClauseType:FunzioneDiRipresa", + "sogg": "hasClauseType:Soggettiva", + "sogg aci": "hasClauseType:Soggettiva", + "sogg id": "hasClauseType:Soggettiva", + "sogg infinitoprep": "hasClauseType:Soggettiva", + "sogg scissa": "hasClauseType:SoggettivaScissa", + "sogg soll": "hasClauseType:SoggettivaASollevamento", + "spec": "hasClauseType:Specificativa", + "spec aci": "hasClauseType:Specificativa", + "spec infinitoprep": "hasClauseType:Specificativa", + "strum": "hasClauseType:Strumentale", + "subord": "hasClauseType:Subordinata", + "temp": "hasClauseType:Temporale", + "temp comp ug": "hasClauseType:TemporaleConValoreComparativo", + "temp ipo": "hasClauseType:TemporaleConValoreIpotetico", +}