cql query option

Reviewed-on: #8

.gitignore

@@ -10,5 +10,5 @@ build/*
 # using kdev4, works fairly nicely!
 .kdev4
 **/*.kdev4
-
+remote
 

res/main.less

@@ -64,13 +64,13 @@
     margin-bottom: 1em;
 
     #headword {
-      font-size: 1.2em; 
+      font-size: 1.2em;
       color: @darkred;
       font-weight: bold;
     }
 
     #grammar {
-      color: @gray; 
+      color: @gray;
       font-style: italic;
       margin-left: 1em;
     }
@@ -90,8 +90,8 @@
   }
 
   #sense-container {
-    border-top: 1px dotted #999999; 
+    border-top: 1px dotted #999999;
-    padding-top: 0.5em; 
+    padding-top: 0.5em;
     margin-top: 0.5em;
 
     .sense-num {
@@ -156,16 +156,7 @@
             vertical-align: super;
             font-size: 0.7em;
           }
-          .translation-explanation:not(:empty) {
-            font-style: italic;
 
-            &:before {
-              content: '[';
-            }
-            &:after {
-              content: ']';
-            }
-          }
         }
 
         .translation-add {
@@ -175,10 +166,24 @@
       }
     }
 
+    .explanations:not(:empty) {
+      font-style: italic;
+
+      &:not(.solo) {
+        &:before {
+          content: '[';
+        }
+
+        &:after {
+          content: ']';
+        }
+      }
+    }
+
     .example {
       clear: left;
       margin-left: 1em;
-      
+
       .example-dot, .example-rest {
         float: left;
         max-width: 90%;
@@ -242,7 +247,7 @@
 
 // if span left of input it is just too high, this is a fix
 .span-left-of-input {
-  margin-top: 0.3em; 
+  margin-top: 0.3em;
 }
 
 
@@ -257,7 +262,7 @@
   .example-cluster {
     color: @blue;
   }
-  .example-logdice { 
+  .example-logdice {
     color: @gray;
   }
   .example-frequency {
@@ -289,7 +294,7 @@
   .example-component-none {
     color: @gray;
   }
-  
+
   .example-component-no-space {
     color: @silver;
   }
@@ -313,7 +318,7 @@
   background-color: rgba(0,0, 0, 0.01);
   padding: 0.5em;
   border: 2px solid gray;
-  margin: 1em; 
+  margin: 1em;
 
   .ske-line {
     display: block;
@@ -325,13 +330,13 @@
 
     .grey1 {
       margin-left: 0.3em;
-      background-color: @silver; 
+      background-color: @silver;
       color: @black;
     }
     .grey2 {
       margin-left: 0.3em;
       background-color: @black;
-      color: @silver; 
+      color: @silver;
     }
 
     .no-gf2-info {
@@ -374,7 +379,7 @@
 //   overflow: scroll;
 //   border: 2px solid red;
 //   height: 10em;
-// 
+//
 //   :nth-last-child(odd) {
 //     background-color: lightgray;
 //   }

src/export.py

@@ -5,7 +5,7 @@ from model.tags import export_tag
 def export_to_xml(model):
     xml_document = export_entry(model.entry)
     serializer = __new__(XMLSerializer())
-    return serializer.serializeToString(xml_document);
+    return serializer.serializeToString(xml_document)
 
 
 def export_entry(entry):
@@ -23,9 +23,14 @@ def export_entry(entry):
 
     headword = doc.createElement("headword")
     headword_lemma = doc.createElement("lemma")
+
+#     headword_lemma = entry.original_xml.querySelector("head headword lemma")
+
     headword_lemma.textContent = entry.headword
     if entry.headword_type is not None:
         headword_lemma.setAttribute("type", entry.headword_type)
+    if entry.headword_audio is not None:
+        headword_lemma.setAttribute("audio", entry.headword_audio)
     headword.appendChild(headword_lemma)
     head.appendChild(headword)
 
@@ -52,12 +57,14 @@ def export_entry(entry):
         lexunit.appendChild(lexeme)
         head.appendChild(lexunit)
 
+
     grammar = doc.createElement("grammar")
     grammar_category = doc.createElement("category")
     grammar_category.textContent = entry.grammar
     grammar.appendChild(grammar_category)
     head.appendChild(grammar)
 
+
     if len(entry.measure) > 0:
         measure_list = doc.createElement("measureList")
         measure = doc.createElement("measure")
@@ -125,7 +132,9 @@ def export_sense(doc, sense):
 
     for example in sense.examples:
         example_container = example.export(doc)
-        export_translation_list(doc, example, example_container)
+        translation_container_list = doc.createElement("translationContainerList")
+        export_translation_list(doc, example, translation_container_list)
+        example_container.appendChild(translation_container_list)
         example_container_list.appendChild(example_container)
 
     return sense_xml
@@ -146,16 +155,27 @@ def export_translation(doc, translation):
     actual_t.textContent = translation.translation
     actual_t.setAttribute("targetLang", translation.targetLang)
 
+    if translation.audio:
+        actual_t.setAttribute("audio", translation.audio)
+
     if translation.source:
         actual_t.setAttribute("source", translation.source)
     translation_xml.appendChild(actual_t)
 
-    explanation = doc.createElement("explanation")
+    if len(translation.explanationList) > 0 :
-    explanation.textContent = translation.explanation
+        explanationList = _export_explanation_list(doc, translation.explanationList)
-    translation_xml.appendChild(explanation)
+        translation_xml.appendChild(explanationList)
+
+
 
     return translation_xml
 
+def _export_explanation_list(doc, lst):
+    result = doc.createElement('explanationList')
+    for explanation in lst:
+            result.appendChild(explanation.export(doc))
+
+    return result
 
 def _export_label_list(doc, lst):
     result = doc.createElement("labelList")

src/lib/structure_conversions.py

@@ -24,29 +24,41 @@ def build_structure_conversions():
         if line[1] == "struktura":
             continue
         
+        vto_structure = line[1].strip().split(">")[1].split("<")[0]
         vto_name = line[2].strip()
-        vto_id = line[4].strip()
+        vto_id = line[6].strip()
         
         if 0 in (len(vto_name), len(vto_id)):
             continue
         
         vfrom = "^" + line[0].replace("?", "\?").replace("%s", "([a-zA-Z螚ȎŠ-]+)") + "$"
-        structure_conversions.append((__new__(RegExp(vfrom, 'u')), vto_name, vto_id))
+        structure_conversions.append((__new__(RegExp(vfrom, 'u')), vto_name, vto_structure, vto_id))
         
         
-def convert_structure(structure):
+def convert_structure(structure, type):
     if structure_conversions is None:
         build_structure_conversions()
     
-    for vfrom, vto_name, vto_id in structure_conversions:
+    for vfrom, vto_name, vto_structure, vto_id in structure_conversions:
         match = structure.match(vfrom)
+        # fix for ids 106, 107, 44 which instead matched with 30
+        if match and vto_id == '30' and '-s' in type:
+            vto_name = 's0-vp-s0'
+            vto_id = '106'
+        elif match and vto_id == '30' and '-g' in type:
+            vto_name = 'gg-vp-gg'
+            vto_id = '107'
+        elif match and vto_id == '30' and '-r' in type:
+            vto_name = 'r-vp-r'
+            vto_id = '44'
+
         if match:
             # we need to remove replace alias here as we want to use javascript's one
             __pragma__('noalias', 'replace')
             result = structure.replace(vfrom, vto_name).strip()
             __pragma__('alias', 'replace', "py_replace")
-            
+
-            return result, vto_id
+            return result, vto_structure, vto_id
     
     window.console.log("Unknown structure: ", structure)
-    return None
+    return 'N/A', '/'

src/message/common_accessors.py

@@ -10,16 +10,19 @@ def generic_list_getter():
     return result
 
 # Formats data from inputs to name-value objects
-def homonymy_list_getter():
+def double_list_getter(firstParameter, secondParameter, allowEmptyField = False):
     result = []
-    for row in document.getElementsByClassName("label-list-row"):
+    for row in document.getElementsByClassName("double-list-row"):
-        value = row.querySelector(".value-input").value
+        firstValue = row.querySelector("." + firstParameter + "-input").value
-        name = row.querySelector(".name-input").value
+        secondValue = row.querySelector("." + secondParameter + "-input").value
 
-        if ("" in [name, value]):
+        if (allowEmptyField is False and '' in [firstValue, secondValue]):
             continue
 
-        result.append({"name": name, "value": value})
+        if (allowEmptyField is True and all('' == value or value.isspace() for value in [firstValue, secondValue])):
+            continue
+
+        result.append({firstParameter: firstValue, secondParameter: secondValue})
 
     return result
 

src/message/simple_edits.py

@@ -90,7 +90,7 @@ class EditVariants(Message):
 
 class EditHomonymy(Message):
     def update_model(self, model):
-        homonymy = common_accessors.homonymy_list_getter()
+        homonymy = common_accessors.double_list_getter("value", "name")
         model.entry.homonymy = homonymy
 
 

src/message/ske_messages.py

@@ -26,6 +26,7 @@ class SkeExample:
         self.mid = ""
         self.s_id = ""
         self.gf2_good = None
+        self.gf2_check = False
     
     @staticmethod
     def fromLine(line):
@@ -58,15 +59,8 @@ class SkeCollocation:
     def __init__(self, data):
         self.word = data.word
         self.frequency = data.count
-        
+        self.gramrel = data.gramrel
-        info = convert_structure(data.gramrel)
+        self.structure_name, self.structure, self.structure_id = convert_structure(data.gramrel, data.lempos)
-        if info is None:
-            self.structure_name = None
-            self.structure_id = None
-        else:
-            self.structure_name = info[0]
-            self.structure_id = info[1]
-            
         
         self.other = {"score": data.score, "cm": data.cm}
 
@@ -79,7 +73,7 @@ class SkeCollocation:
             h("span.grey1", {}, self.other["cm"]),
             h("span", {}, ","),
             h("span.grey2", {}, self.structure_name)])]
-    
+
 
 def get_parser(ske_index_type):
     if ske_index_type == 0:
@@ -109,13 +103,28 @@ def match_gf2_examples(data, *args):
     xhr.send(to_send)
 
 
+def make_cql_query(ske_index, search_term, pos):
+    cql_pos= {
+        "samostalnik": ("S.*", "-s"),
+        "glagol": ("G.*", "-g"),
+        "pridevnik": ("P.*", "-p"),
+        "prislov": ("R.*", "-r"),
+        "zaimek": ("Z.*", "-z")
+    }
+    
+    if ske_index == 0:
+        return "[ lemma=\"{0}\" & tag=\"{1}\" ]".format(search_term, cql_pos[pos][0])
+    else:
+        return search_term + cql_pos[pos][1]
+
+
 class SkeModal(ClickMessage):
     def on_event(self, event):
         # event could be data if this is the return from external library
         if type(event) in [list, int]:
             self.add_arg(event)
         else:
-            if len(self._args) < 4:
+            if len(self._args) < 5:
                 self.add_arg(None)
             super().on_event(event)
         
@@ -123,18 +132,20 @@ class SkeModal(ClickMessage):
         page_num = self.get_arg(0, int)
         search_term = self.get_arg(1, str)
         ske_index = self.get_arg(2, int)
+        ske_pos_query = self.get_arg(3, str)
         ske_lookup = model.ske.url_for_kind_index(ske_index)
         
-        next_message = msg(SkeModal, page_num, search_term, ske_index)
+        next_message = msg(SkeModal, page_num, search_term, ske_index, ske_pos_query)
         
         # could be none if empty
-        data = self.get_arg(3)
+        data = self.get_arg(4)
         
         if data is None:
             params = {"additional_refs": "s.id,p.id",
                       "page_num": page_num,
                       "error_callback": next_message,
-                      "data_parser": get_parser(ske_index)}
+                      "data_parser": get_parser(ske_index),
+                      "querytype": ske_pos_query}
             
             gdex = get_preference("ske_gdex")
             if gdex:
@@ -143,15 +154,36 @@ class SkeModal(ClickMessage):
                     return
                 params["gdex"] = gdex
             
+            # enable CQL query
+            if ske_pos_query is not "simple":
+                search_term_old = search_term
+                search_term = make_cql_query(ske_index, search_term, ske_pos_query)
+
             model.ske.request(search_term, next_message, ske_lookup, params)
-            
+            search_term = search_term_old
+
         elif type(data) is list:
             window.console.log(data)
             # check if gf2 examples are loaded or not
-            if data[0].gf2_good is None:
+            if not data[0].gf2_check and type(data[0]) is SkeExample:
                 # we get the data, we have to match it with available data on our gf2 examples API
-                match_gf2_examples(data, page_num, search_term, ske_index)
+                match_gf2_examples(data, page_num, search_term, ske_index, ske_pos_query)
- 
+            elif type(data[0]) is SkeCollocation:
+                # filtering, grouping and sorting data
+                data.sort(key= lambda x: float(x.other["score"]), reverse=True)
+                _data = []
+                while len(data) > 0:
+                    max_item = data.pop(0) # max(data, key= lambda x: x.other["score"])
+                    _data.append(max_item)
+                    for item in data:
+                        if "N/A" in item.structure_name:
+                            data.remove(item)
+                        elif item.structure_name.strip() == max_item.structure_name.strip():
+                            _data.append(item)
+                    for delete_item in _data:
+                        if delete_item in data:
+                            data.remove(delete_item)                          
+                data = _data
         model.modal_set(lambda: modals.ske_list(
             search_term, data, page_num, model.entry.senses, model.ske.request_kinds))
     
@@ -162,19 +194,25 @@ class SkeModal(ClickMessage):
 class SkeModalGf2Update(SkeModal):
     def on_event(self, event):
         response_data = window.JSON.parse(event.target.response)
-        data = self.get_arg(3)
+        data = self.get_arg(4)
         
         data_dict = {}
         for example in data:
             example.gf_good = False
             data_dict[example.s_id] = example
             
+        bad_response = dict(response_data["bad"])
+        for gf_sid, gf_data in bad_response.items():
+            data_dict[gf_sid].gf2_good = None
+            data_dict[gf_sid].gf2_check = True
+
         good_response = dict(response_data["good"])
         for gf_sid, gf_data in good_response.items():
             data_dict[gf_sid].left = gf_data.left
             data_dict[gf_sid].mid = gf_data.mid
             data_dict[gf_sid].right = gf_data.right
             data_dict[gf_sid].gf2_good = True
+            data_dict[gf_sid].gf2_check = True
         
         # changed data_dict, now we can redraw!
         # just let it do its thing in update_model
@@ -192,6 +230,7 @@ class SearchInSkeModal(SkeModal):
         self.add_arg(int(document.getElementById("ske-page-num").value))
         self.add_arg(document.getElementById("ske-search").value)
         self.add_arg(document.getElementById("ske-select").selectedIndex)
+        self.add_arg(document.getElementById("ske-pos-query").value)
         super().on_event(event)
 
 
@@ -224,6 +263,8 @@ class SkeInsert(DataChgClickMessage):
             else:
                 console.log("You really should not be here, my lady")
                 continue
+        
+        model.reset()
     
     def _as_corpus_example(self, example):
         new_example = Example()
@@ -237,7 +278,7 @@ class SkeInsert(DataChgClickMessage):
         
         lex_mid = ComponentLexeme()
         lex_mid.text = example["mid"]
-        lex_mid.role = "collocation"
+        lex_mid.role = "headword"
         
         lex_right = ComponentLexeme()
         lex_right.text = example["right"]
@@ -256,17 +297,45 @@ class SkeInsert(DataChgClickMessage):
         new_collocation.inner.other_attributes["frequency"] = example.frequency
         new_collocation.inner.type = "collocation"
         
-        lex_left = ComponentLexeme()
+        headword = document.getElementById("ske-search").value       
-        lex_left.text = ""
+        lexemes = []
-        lex_left.role = None
+        structure_name = example.structure_name.split("-")
-        
+        gramrel = example.gramrel.split("_")
-        lex_mid = ComponentLexeme()
+        structure = example.structure.split(" ")
-        lex_mid.text = example.word
+        structure.append("") # Bad fix: we have to add something for structure l-gg-ggn
-        lex_mid.role = "collocation"
+
-        
+        for i in range(len(structure_name)):
-        lex_right = ComponentLexeme()
+            lex = ComponentLexeme()
-        lex_right.text = ""
+            structure[i] = structure[i].replace("Inf-", "")
-        lex_right.role = None
+            
-        
+            # take care of negations "ne"
-        new_collocation.components.extend([lex_left, lex_mid, lex_right])
+            if "Neg-" in structure[i]:
+                structure[i] = structure[i].replace("Neg-", "")
+                negation_flag = True
+                n_lex = ComponentLexeme()
+                n_lex.text = "ne"
+                n_lex.role = "other"
+                lexemes.append(n_lex)
+
+            if structure[i] is "":
+                continue # skipping bcs of fix
+            elif "Vez-gbz" in structure[i]:
+                lex.text = "je"
+                lex.role = "other"                
+            elif structure_name[i] in ["d", "vd", "zp"]:
+                lex.text = gramrel[i]
+                lex.text = lex.text.replace("-d", "").replace("%", "")
+                lex.role = "other"
+            elif structure_name[i] is "vp":
+                lex.text = structure[i]
+                lex.role = "other"
+            elif structure[i][0] in ["S", "G", "P", "R"]:
+                lex.text = headword
+                lex.role = "headword"
+            else:
+                lex.text = example.word
+                lex.role = "collocate"
+            lexemes.append(lex)
+
+        new_collocation.components.extend(lexemes)
         return new_collocation

src/message/translation_edit.py

@@ -4,28 +4,35 @@ import message.common_accessors as common_accessors
 from browser import document, window
 from model.translation import Translation
 from model.sense import Sense
+from model.explanation import Explanation
+
 
 
-                
 class EditTranslation(DataChgClickMessage):
     def update_model(self, model):
         self.translation = self.get_arg(0, Translation)
         self.old_cluster_idx = self.get_arg(1, int)
-        
+
         self.translation.translation = document.getElementById("etv").value
-        self.translation.explanation = document.getElementById("ete").value
+#         This could be dangerous if double_list_getter is getting data from any other list as well.
-        
+        explanations = common_accessors.double_list_getter('value', 'language', True)
+        self.translation.explanationList = []
+        for entry in explanations:
+            explanation = Explanation()
+            explanation.value = entry.value
+            explanation.language = entry.language
+            self.translation.explanationList.append(explanation)
         # common_accessors.label_list_getter()
         self.translation.tags = common_accessors.label_list_getter()
-        
+
         # check if empty, remove!
         if self.translation.is_empty():
             model.entry.remove_translation(self.translation)
             return
-        
+
         new_cluster_idx = int(document.getElementById("cluster-num").value) - 1
         self.handle_cluster_change(new_cluster_idx, model)
-        
+
     @staticmethod
     def get_translation_location(entry, translation):
         def find_in_clusters(parent):
@@ -34,7 +41,7 @@ class EditTranslation(DataChgClickMessage):
                     if search_translation == translation:
                         return (ci, ti), (parent, cluster)
             return None
-                            
+
         for sense in entry.senses:
             res = find_in_clusters(sense)
             if res is not None:
@@ -43,21 +50,21 @@ class EditTranslation(DataChgClickMessage):
                 res = find_in_clusters(example)
                 if res is not None:
                     return res
-    
+
     window.console.log("should not be here...")
-                
+
-    
+
     def handle_cluster_change(self, new_cluster_idx, model):
         if self.old_cluster_idx == new_cluster_idx:
             return
-        
+
         (cidx, tidx), (parent, cluster) = EditTranslation.get_translation_location(model.entry, self.translation)
         self.do_cluster_change(parent, cluster, cidx, tidx, new_cluster_idx)
-        
+
     def do_cluster_change(self, sense_or_example, cluster, cidx, tidx, new_cluster_idx):
         # remove the translation from the old cluster
         cluster.splice(tidx, 1)
-                        
+
         # we maybe are creating a new cluster, handle that
         if len(sense_or_example.translations) == new_cluster_idx:
             sense_or_example.translations.append([self.translation])
@@ -66,12 +73,12 @@ class EditTranslation(DataChgClickMessage):
             sense_or_example.translations[new_cluster_idx].append(self.translation)
         else:
             raise ValueError("Bad new cluster idx :(")
-            
+
         # we still hold cluster reference, check if empty and remove if necessary
         # we cant do this earlier since indexes change and yeah, fun stuff
         if len(cluster) == 0:
             sense_or_example.translations.splice(cidx, 1)
-            
+
 
 class MoveRight(DataChgClickMessage):
     def update_model(self, model):
@@ -80,8 +87,8 @@ class MoveRight(DataChgClickMessage):
         if idx != len(cluster) - 1:
             cluster[idx], cluster[idx + 1] = cluster[idx + 1], cluster[idx]
         model.translation = None
-        
+
-        
+
 class MoveLeft(DataChgClickMessage):
     def update_model(self, model):
         translation = self.get_arg(0, Translation)
@@ -89,8 +96,8 @@ class MoveLeft(DataChgClickMessage):
         if idx != 0 and len(cluster) > 1:
             cluster[idx], cluster[idx - 1] = cluster[idx - 1], cluster[idx]
         model.translation = None
-        
+
-        
+
 class BinTranslation(DataChgClickMessage):
     def update_model(self, model):
         translation = self.get_arg(0, Translation)
@@ -101,7 +108,7 @@ class BinTranslation(DataChgClickMessage):
         else:
             cluster.splice(tidx, 1)
         model.translation = None
-        
+
 
 class AddTranslation(EditTranslation):
     def handle_cluster_change(self, new_cluster_idx, _):
@@ -110,4 +117,4 @@ class AddTranslation(EditTranslation):
         # we make a dummy cluster, cluster_idx and translation_idx
         # we give a correct new_cluster_idx
         self.do_cluster_change(self.get_arg(2), [None, None], None, None, new_cluster_idx)
-        
+

src/model/__init__.py

@@ -2,3 +2,4 @@ from model.model import Model
 from model.sense import Sense
 from model.translation import Translation
 from model.example import Example
+from model.explanation import Explanation

src/model/entry.py

@@ -14,6 +14,7 @@ class Entry(Data):
         self.headword = ""
         self.homonymy = []
         self.headword_type = None
+        self.headword_audio = None
         self.grammar = ""
         self.comment = ""
         self.variants = []
@@ -22,16 +23,20 @@ class Entry(Data):
         self.measure = {}
         self.labels = []
         self.senses = []
+        self.original_xml = None
 
     def import_xml(self, entry_xml):
+        self.original_xml = entry_xml.cloneNode(True)
         status = entry_xml.querySelector("head status")
+
         headword = entry_xml.querySelector("head headword lemma")
 
         grammar = entry_xml.querySelector("head grammar category")
         comment = entry_xml.querySelector("head comment")
         self.status = status.textContent if status else ""
         self.headword = headword.textContent if headword else ""
-        self.headword_type = headword.getAttribute("type") if headword else None
+        self.headword_type = headword.getAttribute("type") if headword and headword.hasAttribute("type") else None
+        self.headword_audio = headword.getAttribute("audio") if headword and headword.hasAttribute("audio") else None
         self.grammar = grammar.textContent if grammar else ""
         self.comment = comment.textContent if comment else ""
         self.variants = [v.textContent for v in entry_xml.querySelectorAll("head variantList variant")]

src/model/example/component_lexeme.py

@@ -11,7 +11,7 @@ class ComponentLexeme(Data):
         self.text = ""
         self.role = ""
         self.no_space = False
-    
+
     def import_xml(self, xml):
         if xml.nodeName == "#text":
             self.text = xml.data
@@ -19,33 +19,31 @@ class ComponentLexeme(Data):
         else:
             self.text = xml.textContent
             self.role = xml.getAttribute("role")
-            
             if xml.hasAttribute("space"):
                 self.no_space = xml.getAttribute("space") == "false"
 
-            for oth_attr in ["lexical_unit_lexeme_id", "slolex", "kol"]:
+            for oth_attr in ["lexeme_id", "lexical_unit_lexeme_id", "slolex", "kol", "sloleks"]:
                 if xml.hasAttribute(oth_attr):
                     self.other_attributes[oth_attr] = xml.getAttribute(oth_attr)
-    
+
     def isValid(self):
         return len(self.text) > 0
-    
+
     def export(self, doc):
         if self.role is None:
             return doc.createTextNode(self.text)
-        
         result = doc.createElement("comp")
         result.setAttribute("role", self.role)
         result.textContent = self.text
-        
+
         if self.no_space and self.no_space != self.LAST_COMPONENT_SPACE:
             result.setAttribute("space", "false")
-        
+
         for key, value in self.other_attributes.items():
             result.setAttribute(key, value)
-        
+
         return result
-    
+
     def view_style(self):
         # no-space is handled in multiword-example directly
         result = ".comp-text"
@@ -53,8 +51,8 @@ class ComponentLexeme(Data):
             result += ".comp-role"
             if self.role == "headword":
                 result += ".comp-role-headword"
-                
+
         return result
-        
+
 
 

src/model/example/example.py

@@ -18,12 +18,12 @@ class Example(Data):
         self.components = []
         self.edited = False
         self.newly_created = False
-    
+
     # removes space from last component if multiword example
     def check_multiword_components(self):
         if self.is_multiword():
             self.components[len(self.components) - 1].no_space = ComponentLexeme.LAST_COMPONENT_SPACE
-    
+
     @staticmethod
     def new_multiword():
         example = Example()
@@ -32,105 +32,105 @@ class Example(Data):
         example.inner = MultiwordExample()
         example.inner.cluster = ExampleClusters.first_empty_cluster()
         example.inner.type = "grammaticalCombination"
-        
+
         empty_component = ComponentLexeme()
         empty_component.role = "headword"
         example.components.append(empty_component)
-        
+
         return example
-    
+
     def import_xml(self, example_xml):
-        self.translations = from_container_list(example_xml.querySelectorAll("translationContainer"))
+        self.translations = from_container_list(example_xml.querySelectorAll("translationContainerList translationContainer"))
-        
+
         if example_xml.hasAttribute("modified"):
             self.edited = example_xml.getAttribute("modified") == "true"
-                
+
         inner_xml = example_xml.querySelector("corpusExample")
         if inner_xml is not None:
             self.inner = CorpusExample()
         else:
-            inner_xml = example_xml.querySelector("multiwordExample") 
+            inner_xml = example_xml.querySelector("multiwordExample")
             self.inner = MultiwordExample()
-        
+
         self.inner.import_xml(inner_xml)
-        
+
         for idx, comp_xml in enumerate(inner_xml.childNodes):
             comp = ComponentLexeme()
             comp.import_xml(comp_xml)
             if comp.isValid():
                 self.components.append(comp)
-        
+
         self.check_multiword_components()
-        
+
     def export(self, doc):
         self.check_multiword_components()
-        
+
         result = doc.createElement("exampleContainer")
-        
+
         inner = self.inner.export(doc, self.edited)
         # TODO: bad quick fix
         for comp in self.components:
             inner.appendChild(comp.export(doc))
-        
+
         result.appendChild(inner)
         return result
-    
+
     def view(self, model, sense):
         example_tag = "div.example-rest"
         if self in model.chosen_examples:
             example_tag += ".example-chosen"
-                
+
         cluster = self.get_cluster()
         dot_attr = {"style": { "visibility": "visible" if cluster is None else "hidden"}}
-        
+
         example_content = []
         if cluster is not None:
             example_content.append(h("span.example-cluster", {}, str(cluster + 1)))
-        
+
         example_text_inner_tag = "span.example-text-{}".format(self.get_view_type())
         example_content.append(h(example_text_inner_tag, {}, self.inner.view(self.components)))
-        
+
         other_attributes = self.get_other_attributes()
         if "frequency" in other_attributes:
             example_content.append(h("span.example-frequency", {}, other_attributes["frequency"]))
         if "logDice" in other_attributes:
             example_content.append(h("span.example-logdice", {}, other_attributes["logDice"]))
-        
+
         parent_display = "none"
         if model.examples_shown or self.is_multiword() or len(self.translations) > 0:
             parent_display = "inherit"
-        
+
         clusters_display = "inherit"
         if not model.clusters_shown:
             clusters_display = "none"
-        
+
         return h("div.example", {"style": {"display": parent_display}}, [
           h("div.example-dot", dot_attr, "▣"),
           h(example_tag, {}, [
             h("span.example-text", {"on": {"click": M.msg(M.ShowExampleMenu, self)} }, example_content),
             h("div.example-translation-list", {}, [
               h("div.example-translation", {}, View.view_translations(self.translations, self, model))]),
-            h("div.example-clusters", 
+            h("div.example-clusters",
               {"style": {"display": clusters_display }}, show_toggle_cluster_buttons(sense, self))])])
-    
+
     def simple_view(self):
         return self.inner.view(self.components)
-        
+
     def get_cluster(self):
         return self.inner.get_cluster()
-    
+
     def set_cluster(self, cluster):
         self.inner.cluster = cluster
-    
+
     def get_structure(self):
         return self.inner.get_structure()
-    
+
     def is_collocation(self):
         return self.get_view_type() == 2
-    
+
     def is_multiword(self):
         return self.get_view_type() != 1
-    
+
     def get_view_type(self):
         # as per the bosses, these are the rules for different colors
         if type(self.inner) is CorpusExample:
@@ -139,8 +139,8 @@ class Example(Data):
             return 2
         else:
             return 3
-    
+
     def get_other_attributes(self):
         return self.inner.other_attributes
-            
+
-            
+

src/model/explanation.py

@@ -0,0 +1,21 @@
+from model.data import Data
+
+from lib.snabbdom import h
+
+
+class Explanation(Data):
+    def __init__(self):
+        self.value = ""
+        self.language = ""
+
+    def import_dom(self, explanation_dom):
+
+        self.value = explanation_dom.textContent if explanation_dom else ""
+        self.language = explanation_dom.getAttribute("language") if explanation_dom.hasAttribute("language") else ""
+
+    def export(self, doc):
+        result = doc.createElement("explanation")
+        result.textContent = self.value
+        if self.language != "": result.setAttribute('language', self.language)
+
+        return result

src/model/sense.py

@@ -15,37 +15,37 @@ class Sense(Data):
         self.labels = []
         self.translations = []
         self.examples = []
-    
+
     def import_xml(self, sense_xml, idx):
         self.original_idx = idx
+
         for definition in sense_xml.querySelectorAll("definitionList definition"):
             key = definition.getAttribute("type")
             self.definition[key] = definition.textContent
-        
+
         self.labels = import_label_list("sense > labelList label", sense_xml)
         self.translations = from_container_list(
-            sense_xml.querySelectorAll("translationContainerList translationContainer"))
+            sense_xml.querySelectorAll('sense > translationContainerList translationContainer'))
-        
         for example_xml in sense_xml.querySelectorAll("exampleContainerList exampleContainer"):
             example = Example()
             example.import_xml(example_xml)
             self.examples.append(example)
-                         
+
-        
+
     def merge_labels(self):
         return ", ".join(val for _, val in self.labels)
-    
+
-    
+
     def view(self, model, sense_num):
         examples = [example.view(model, self) for example in self.examples]
-        
+
         result = h("div.elm-div", {}, [
           h("div.sense-num", {"on": {"click": M.msg(M.ShowSenseMenu, self)}}, str(sense_num + 1)),
           h("div.sense", {}, [
             h("span.sense-label-list", { "on": { "click": M.msg(M.ShowSenseLabelEdit, self) }}, [
-                h("span.sense-label", {}, clean_label(slabel)) for _, slabel in self.labels ]), 
+                h("span.sense-label", {}, clean_label(slabel)) for _, slabel in self.labels ]),
             h("span.sense-definition", { "on": { "click": M.msg(M.ShowSenseDefinitionEdit, self) }}, self.definition["indicator"]),
             h("div", {}, View.view_translations(self.translations, self, model)),
             h("div", {}, examples)])])
         return result
-                
+

src/model/translation.py

@@ -1,4 +1,5 @@
 from model.tags import import_label_list
+from model.explanation import Explanation
 from model.data import Data
 
 from lib.snabbdom import h
@@ -9,21 +10,21 @@ import message as M
 def from_container_list(translation_list_container_xml):
     translations = []
     max_num_cluster = 0
-    
+
     for translation_xml in translation_list_container_xml:
         num_cluster = 1 # default cluster
         if translation_xml.hasAttribute("cluster"):
             num_cluster = int(translation_xml.getAttribute("cluster"))
-            
+
         max_num_cluster = max(max_num_cluster, num_cluster)
         t = Translation()
         t.import_xml(translation_xml)
         translations.append((num_cluster, t))
-        
+
     result = [[] for _ in range(max_num_cluster)]
     for clusterNum, translation in translations:
         result[clusterNum - 1].append(translation)
-        
+
     return result
 
 
@@ -32,47 +33,54 @@ class Translation(Data):
         self.translation = ""
         self.source = ""
         self.targetLang = ""
-        self.explanation = ""
+        self.audio = ""
+        self.explanationList = set()
         self.tags = []
-    
+
     def import_xml(self, translation_xml):
         translation = translation_xml.querySelector("translation")
-        
+
         if translation:
             self.translation = translation.textContent
             self.source = translation.getAttribute("source") if translation.hasAttribute("source") else ""
             self.targetLang = translation.getAttribute("targetLang")  if translation.hasAttribute("targetLang") else ""
-        
+            self.audio = translation.getAttribute("audio")  if translation.hasAttribute("audio") else ""
-        explanation = translation_xml.querySelector("explanation")
+
-        self.explanation = explanation.textContent if explanation else ""
+        explanationList = translation_xml.querySelectorAll("explanationList explanation")
+        for explanation_dom in explanationList:
+            explanation = Explanation()
+            explanation.import_dom(explanation_dom)
+            self.explanationList.append(explanation)
+
         self.tags = import_label_list("labelList label", translation_xml)
-    
+
-    
     def view(self, model):
         elements = []
-    
+
         if self.tags:
             tags = h("div.translation-tags", {}, [
-              h("span", {"attr": {"title": key}}, clean_label(value)) 
+              h("span", {"attr": {"title": key}}, clean_label(value))
               for key, value in self.tags])
             elements.append(tags)
-        
+
         elements.append(h("span.translation-text", {}, self.translation))
         if self.source:
             elements.append(h("span.translation-source", {}, self.source))
-            
+
-        explanation_class = ".translation-explanation" if self.translation else ""
+        if (self.explanationList):
-        elements.append(h("span{}".format(explanation_class), {}, self.explanation))
+            explanation_class = ".explanations" if self.translation else ".explanations.solo"
-            
+            explanations = [explanation.value for explanation in self.explanationList]
+            elements.append(h("span{}".format(explanation_class), {}, ", ".join(explanations)))
+
         return h("div.translation-div", {"on": {"click": M.msg(M.ShowTranslationMenu, self) }}, elements)
 
-    
+
     def is_empty(self):
         result = True
         result = result and self.translation == ""
         # next two are not checked as the also can not be deleted via gui
         # result = result and self.source == ""
         # result = result and self.targetLang == ""
-        result = result and self.explanation == ""
+        result = result and len(self.explanationList) == 0
         result = result and len(self.tags) == 0
         return result

src/view/modal_templates.py

@@ -49,7 +49,7 @@ def generic_list_editor(title, element_list_getter):
 
 def homonymy_editor(title, current_labels):
     def split_line2(left, right):
-        cls = "flex.two{}".format(".label-list-row")
+        cls = "flex.two{}".format(".double-list-row")
         return h("div.{}".format(cls), {}, [
             h("div.half", {}, left), h("div.half", {}, right)])
 
@@ -67,6 +67,28 @@ def homonymy_editor(title, current_labels):
 
     return content
 
+def explanation_editor(title, current_labels):
+    def split_line2(left, right):
+            cls = "flex.two{}".format(".double-list-row")
+            return h("div.{}".format(cls), {}, [
+                h("div.four-fifth", {}, left), h("div.fifth", {}, right)])
+
+    content = [h("p", {}, title)]
+    for i, explanation in enumerate(current_labels()):
+        language = []
+        value = []
+        language.append(h("label", {"attrs": {"for": i}}, "Language:"))
+        language.append(h("input.language-input", {"props": {"type": "text", "value": explanation["language"], "id": i}}, ""))
+        value.append(h("label", {"attrs": {"for": i + "-value"}}, "Value:"))
+        value.append(h("input.value-input", {"props": {"type": "text", "value": explanation["value"], "id": i + "-value"}}, ""))
+
+        content.append(split_line2(value, language))
+    content.append(h("button", {"on": {"click": message.msg(message.AddToGenericList, current_labels)}}, "+"))
+
+    return content
+
+
+
 def label_list_editor(current_labels, add_label_message_class):
     def split_line3(left, center, right, is_llr=True):
         cls = "flex.three{}".format(".label-list-row" if is_llr else "")

src/view/modals.py

@@ -19,10 +19,9 @@ def edit_translation(translation, parent, cluster_idx, num_clusters, cls):
 
     # first line: transalation itself
     content.extend([
-        split_line2("Prevedek:",
+        split_line2("Prevedek:", h("textarea#etv", {"props": {"value": translation.translation}}, ""))])
-                    h("textarea#etv", {"props": {"value": translation.translation}}, "")),
+
-        split_line2("Razlaga:",
+    content.extend(explanation_editor("Razlage:", lambda: translation.explanationList))
-                    h("textarea#ete", {"props": {"value": translation.explanation}}, ""))])
 
     # cluster number
     options = [h("option", {"props": {"selected": idx == cluster_idx}}, str(idx + 1)) for idx in range(num_clusters + 1)]
@@ -65,14 +64,18 @@ def edit_example(example, sense):
             result.append(h("span.example-component-button.example-component-none",
             {"on": {"click": role_msg(idx, "none")}}, "N"))
 
-        result.extend([
+        if "-" not in example.inner.other_attributes["structureName"]:
-            h("span.example-component-button",
+            result.extend([
-            {"on": {"click": message.msg(message.ExampleComponentAdd, example_original, idx)}}, "+"),
+                h("span.example-component-button",
-            h("span.example-component-button",
+                {"on": {"click": message.msg(message.ExampleComponentAdd, example_original, idx)}}, "+"),
-            {"on": {"click": message.msg(message.ExampleComponentRemove, example_original, idx)}}, "-")])
+                h("span.example-component-button",
+                {"on": {"click": message.msg(message.ExampleComponentRemove, example_original, idx)}}, "-")])
 
         return result
 
+    divs.append(h("div.flex.five.example-component", {}, [h("div.one-fifth", {}, "Struktura:"),
+        h("div.three-fifth", {}, example.inner.other_attributes["structureName"])]))
+
     for idx, component in enumerate(example.components):
         role_txt = component.role if component.role is not None else "none"
         color_class = ".example-component-" + role_txt
@@ -178,6 +181,10 @@ def ske_list(search_term, data, page_num, senses, ske_kinds):
                     "type": "number",
                     "min": 1,
                     "step": 1}}, "")]),
+            h("label.fourth.ske-mid-input", {}, [
+                h("select#ske-pos-query", {}, [h("option", {}, "{}".format(pos)) for pos in ["simple", "samostalnik", "glagol", "pridevnik", "prislov", "zaimek"]])
+            ]),
+
             h("span.fourth.button.ske-right-button",
               {"on": {"click": message.msg(message.SearchInSkeModal)}}, "Isci")]),
         h("div.ske-list",

src/view/view.py

@@ -58,7 +58,7 @@ class View:
     def view_ske_button(model):
         return h(
             "span#ske-button.button.toggle", 
-            { "on": {"click": msg(ShowSkeModal, 1, model.entry.headword, 0)} }, 
+            { "on": {"click": msg(ShowSkeModal, 1, model.entry.headword, 0, "simple")} }, 
             h("svg#ske-img", {
                 "attrs": {
                     "xmlns": "http://www.w3.org/2000/svg",