Remove copying example on edit for stuff to work. Don't know what doesn't work

src/export.py

@@ -1,168 +1,203 @@
 from browser import document
 from model.tags import export_tag
-from model.translation import Translation
+
 
 def export_to_xml(model):
     xml_document = export_entry(model.entry)
     serializer = __new__(XMLSerializer())
     return serializer.serializeToString(xml_document)
 
-
 def export_entry(entry):
     parser = __new__(DOMParser())
     doc = parser.parseFromString("<entry />", "text/xml")
     entry_xml = doc.firstChild
 
     # create head
+    head = entry.original_xml.querySelector("head")
+    if head is None:
         head = doc.createElement("head")
-    entry_xml.appendChild(head)
+        entry.original_xml.appendChild(head)
+#     entry_xml.appendChild(head.cloneNode(True))
 
-    status = doc.createElement("status")
+    status = _original_xml_query_selector("head status", entry, doc)
     status.textContent = entry.status
-    head.appendChild(status)
+#     head.appendChild(status.cloneNode(True))
 
-    headword = doc.createElement("headword")
-    headword_lemma = doc.createElement("lemma")
 
-#     headword_lemma = entry.original_xml.querySelector("head headword lemma")
+
+#     headword = doc.createElement("headword")
+#     headword_lemma = doc.createElement("lemma")
+
+    headword = _original_xml_query_selector("head headword", entry, doc)
+    headword_lemma = _original_xml_query_selector("head headword lemma", entry, doc)
 
     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)
 
-    homonymy = doc.createElement("homonymy")
+#     headword.appendChild(headword_lemma.cloneNode(True))
-    headword.appendChild(homonymy)
+#     head.appendChild(headword.cloneNode(True))
+    homonymy = _original_xml_query_selector("head headword homonymy", entry, doc)
+    original_homonymy = entry.original_xml.querySelectorAll("head headword homonymy homonymyFeature")
 
     for hFeature in entry.homonymy:
         feature = doc.createElement("homonymyFeature")
-        feature.textContent = hFeature.value
+        if hFeature.id >= 0:
-#       Can't use hFeature.name, because Python has name reserver and so it becomes py_name in JS
+            feature = original_homonymy[hFeature.id]
-        feature.setAttribute("name", hFeature["name"])
+        else:
             homonymy.appendChild(feature)
 
+        feature.textContent = hFeature.value
+#       Can't use hFeature.name, because Python has name reserved and so it becomes py_name in JS
+        feature.setAttribute("name", hFeature["name"])
+
+
 
     # if({}) works uncorrectly in transcrypt
-    if len(entry.lexical_unit) > 0 and len(entry.lexical_unit['lexemes']) > 0:
+    if len(entry.lexical_unit) > 0:
-        lexunit = doc.createElement("lexicalUnit")
+        lexunit = _original_xml_query_selector("head lexicalUnit", entry, doc)
-        if(entry.lexical_unit["id"]):
+#         lexunit = doc.createElement("lexicalUnit")
         lexunit.setAttribute("id", entry.lexical_unit["id"])
-        lexunit.setAttribute("type", entry.lexical_unit['type'])
+        lexunit.setAttribute("type", "single")
-        for lexeme in entry.lexical_unit["lexemes"]:
+        lexeme = _original_xml_query_selector("head lexicalUnit lexeme", entry, doc)
-            lexeme_xml = doc.createElement("lexeme")
+#         lexeme = doc.createElement("lexeme")
-            if(lexeme["id"]):
+        lexeme.setAttribute("lexical_unit_lexeme_id", entry.lexical_unit["id"])
-                lexeme_xml.setAttribute("lexical_unit_lexeme_id", lexeme["id"])
+        lexeme.textContent = entry.lexical_unit["text"]
-            lexeme_xml.textContent = lexeme["text"]
-            if len(entry.lexical_unit["lexemes"]) > 1:
-                component = doc.createElement('component')
-                component.appendChild(lexeme_xml)
-                lexunit.appendChild(component)
-            else:
-                lexunit.appendChild(lexeme_xml)
-        head.appendChild(lexunit)
 
+#         lexunit.appendChild(lexeme.cloneNode(True))
+#         head.appendChild(lexunit.cloneNode(True))
 
-    grammar = doc.createElement("grammar")
+#   Example of keeping original xml and adding changes to it only
-    grammar_category = doc.createElement("category")
+    grammar = _original_xml_query_selector("head grammar", entry, doc)
+    grammar_category = _original_xml_query_selector("head grammar category", entry, doc)
     grammar_category.textContent = entry.grammar
-    grammar.appendChild(grammar_category)
-    head.appendChild(grammar)
 
+#     head.appendChild(grammar.cloneNode(True))
+    console.log(entry.original_xml)
 
     if len(entry.measure) > 0:
-        measure_list = doc.createElement("measureList")
+        measure_list = _original_xml_query_selector("head measureList", entry, doc)
-        measure = doc.createElement("measure")
+        measure = _original_xml_query_selector("head measureList measure", entry, doc)
+
+#         measure_list = doc.createElement("measureList")
+#         measure = doc.createElement("measure")
         measure.setAttribute("source", entry.measure["source"])
         measure.setAttribute("type", entry.measure["type"])
         measure.textContent = entry.measure["text"]
 
-        measure_list.appendChild(measure)
+#         head.appendChild(measure_list)
-        head.appendChild(measure_list)
-
-    variants = doc.createElement("variantList")
-    head.appendChild(variants)
 
+#     Same problem as homonymy
+    variants = _original_xml_query_selector("head variantList", entry, doc)
+    og_variants = entry.original_xml.querySelectorAll("head variantList variant")
     for v in entry.variants:
         variant = doc.createElement("variant")
-        variant.textContent = v
+        if v.id >= 0:
+            variant = og_variants[v.id]
+        else:
             variants.appendChild(variant)
 
-    relist = doc.createElement("relatedEntryList")
+        variant.textContent = v.value
-    head.appendChild(relist)
 
+#     relist = _original_xml_query_selector("head relatedEntryList", entry, doc)
+#     relist = doc.createElement("relatedEntryList")
+    relist = _original_xml_query_selector("head relatedEntryList", entry, doc)
+    og_relist = entry.original_xml.querySelectorAll("head relatedEntryList relatedEntry")
+#     head.appendChild(relist.cloneNode(True))
     for re in entry.related_entries:
         relateEntry = doc.createElement("relatedEntry")
-        relateEntry.textContent = re
+
+        if re.id >= 0:
+            relateEntry = og_relist[re.id]
+        else:
             relist.appendChild(relateEntry)
 
-    head.appendChild(_export_label_list(doc, entry.labels))
+        relateEntry.textContent = re.value
+    _export_label_list(doc, entry.labels, head)
 
-    comment = doc.createElement("comment")
+#     comment = doc.createElement("comment")
+    comment = _original_xml_query_selector("head comment", entry, doc)
     comment.textContent = entry.comment
-    head.appendChild(comment)
+#     head.appendChild(comment.cloneNode(True))
 
     # now lets do body
+
+    body = entry.original_xml.querySelector("body")
+    if body is None:
         body = doc.createElement("body")
-    entry_xml.appendChild(body)
+        entry.original_xml.appendChild(body)
-
+#     entry_xml.appendChild(body)
-    sense_list = doc.createElement("senseList")
-    body.appendChild(sense_list)
 
+#     sense_list = doc.createElement("senseList")
+    sense_list = _original_xml_query_selector("body senseList", entry, doc)
     for sense in entry.senses:
-        sense_list.appendChild(export_sense(doc, sense))
-
-    return doc
-
-
-def export_sense(doc, sense):
         sense_xml = doc.createElement("sense")
-    sense_xml.appendChild(_export_label_list(doc, sense.labels))
 
-    if sense.id is not None:
+        if sense.original_xml is not None:
-        sense_xml.setAttribute("id", sense.id)
+            sense_xml = sense.original_xml
 
+        sense_list.appendChild(sense_xml)
+        export_sense(doc, sense, sense_xml)
+
+    return entry.original_xml
+
+
+def export_sense(doc, sense, sense_xml):
+    _export_label_list(doc, sense.labels, sense_xml)
+
+    definition_list = sense_xml.querySelector("definitionList")
+    if definition_list is None:
         definition_list = doc.createElement("definitionList")
         sense_xml.appendChild(definition_list)
 
     for definition in sense.definitions:
-        definition_xml = doc.createElement("definition")
+        definition_xml = definition.original_xml if definition.original_xml != None else doc.createElement("definition")
-        definition_xml.textContent = definition["value"]
-        definition_xml.setAttribute("type", definition["type"])
         definition_list.appendChild(definition_xml)
+        definition_xml.textContent = definition.value
+        definition_xml.setAttribute("type", definition.type)
 
+    translation_container_list = sense_xml.querySelector("sense > translationContainerList")
+    if translation_container_list is None:
         translation_container_list = doc.createElement("translationContainerList")
-    export_translation_list(doc, sense, translation_container_list)
         sense_xml.appendChild(translation_container_list)
+    export_translation_list(doc, sense, translation_container_list)
 
+    example_container_list = sense_xml.querySelector("sense > exampleContainerList")
+    if example_container_list is None:
         example_container_list = doc.createElement("exampleContainerList")
         sense_xml.appendChild(example_container_list)
 
     for example in sense.examples:
-        example_container = example.export(doc)
+        example_container = example.export(doc, example_container_list)
-        translation_container_list = doc.createElement("translationContainerList")
+
-        export_translation_list(doc, example, translation_container_list)
+        translation_container_list = example_container.querySelector("exampleContainer > translationContainerList")
-        example_container.appendChild(translation_container_list)
+        if translation_container_list is None:
-        example_container_list.appendChild(example_container)
+            translation_container_list = doc.createElement("translationContainerList")
+            example_container.appendChild(translation_container_list)
+
+        export_translation_list(doc, example, translation_container_list)
 
-    return sense_xml
 
 def export_translation_list(doc, py_parent, xml_parent):
     for cidx, cluster in enumerate(py_parent.translations):
-        if len(cluster) > 0:
         for translation in cluster:
-                translation_container = export_translation(doc, translation)
+            translation_container = export_translation(doc, translation, xml_parent)
             translation_container.setAttribute("cluster", str(cidx + 1))
-                xml_parent.appendChild(translation_container)
+#             xml_parent.appendChild(translation_container)
 
 
-def export_translation(doc, translation):
+def export_translation(doc, translation, xml_parent):
-    translation_xml = doc.createElement("translationContainer")
+    translation_xml = translation.original_xml if translation.original_xml != None else doc.createElement("translationContainer")
-    translation_xml.appendChild(_export_label_list(doc, translation.tags))
+    xml_parent.appendChild(translation_xml)
+    _export_label_list(doc, translation.tags, translation_xml)
+
+    console.log(translation)
+    actual_t = translation.original_xml.querySelector("translation") if translation.original_xml != None else doc.createElement("translation")
+    if translation.original_xml is None:
+        translation_xml.appendChild(actual_t)
 
-    actual_t = doc.createElement("translation")
     actual_t.textContent = translation.translation
     actual_t.setAttribute("targetLang", translation.targetLang)
 
@@ -171,32 +206,38 @@ def export_translation(doc, translation):
 
     if translation.source:
         actual_t.setAttribute("source", translation.source)
-    translation_xml.appendChild(actual_t)
 
     if len(translation.explanationList) > 0 :
-        explanationList = _export_explanation_list(doc, translation.explanationList)
+        _export_explanation_list(doc, translation.explanationList, translation_xml)
-        translation_xml.appendChild(explanationList)
-
-
 
     return translation_xml
 
-def _export_explanation_list(doc, lst):
+def _export_explanation_list(doc, lst, xml_parent):
-    result = doc.createElement('explanationList')
+    result = xml_parent.querySelector("explanationList")
+    if result is None:
+        result = doc.createElement("explanationList")
+        xml_parent.appendChild(result)
+
     for explanation in lst:
         result.appendChild(explanation.export(doc))
 
-    return result
+def _export_label_list(doc, lst, xml_parent):
-
+    result = xml_parent.querySelector("labelList")
-def _export_label_list(doc, lst):
+    if result is None:
         result = doc.createElement("labelList")
-    for key, value in lst:
+        xml_parent.appendChild(result)
-        key, value = export_tag(key, value)
 
+    for key, value, idx in lst:
+
+        key, value = export_tag(key, value)
         label_el = doc.createElement("label")
+        if idx >= 0:
+            label_el = result.querySelectorAll("label")[idx]
+        else:
+            result.appendChild(label_el)
+
         label_el.textContent = value
         label_el.setAttribute('type', key)
-        result.appendChild(label_el)
     return result
 
 def _original_xml_query_selector(selector, entry, doc, parent_selector = selector.rsplit(' ', 1)[0]):
@@ -205,136 +246,3 @@ def _original_xml_query_selector(selector, entry, doc, parent_selector = selecto
         query = doc.createElement(selector.rsplit(' ', 1)[1])
         entry.original_xml.querySelector(parent_selector).appendChild(query)
     return query
-
-def export_example_to_entry_xml(example, other_examples = None):
-    parser = __new__(DOMParser())
-    doc = parser.parseFromString("<entry />", "text/xml")
-    entry_xml = doc.firstChild
-
-    head = doc.createElement("head")
-    entry_xml.appendChild(head)
-
-    status = doc.createElement("status")
-    head.appendChild(status)
-
-    headword = doc.createElement("headword")
-    head.appendChild(headword)
-
-    lemma = doc.createElement("lemma")
-    lemma.textContent = " ".join(comp.text for comp in example.components)
-    lemma.setAttribute("type", "compound")
-    if example.inner.other_attributes['audio'] is not None:
-        lemma.setAttribute('audio', example.inner.other_attributes['audio'])
-    headword.appendChild(lemma)
-
-    homonymy = doc.createElement("homonymy")
-    headword.appendChild(homonymy)
-
-    lexical_unit = doc.createElement("lexicalUnit")
-    lexical_unit.setAttribute("type", "MWE")
-    head.appendChild(lexical_unit)
-    if example.inner.other_attributes['structure_id'] != None and len(example.components) <= 3:
-        lexical_unit.setAttribute("id", example.inner.other_attributes['structure_id'])
-    for comp in example.components:
-        lexeme = doc.createElement("lexeme")
-        lexeme.textContent = comp.text
-        comp_xml = doc.createElement("component")
-        lexical_unit.appendChild(comp_xml)
-        comp_xml.appendChild(lexeme)
-
-    grammar = doc.createElement("grammar")
-    category = doc.createElement("category")
-    grammar.appendChild(category)
-    head.appendChild(grammar)
-
-    variant_list = doc.createElement("variantList")
-    head.appendChild(variant_list)
-    related_entry_list = doc.createElement("relatedEntryList")
-    head.appendChild(related_entry_list)
-    label_list = doc.createElement("labelList")
-    head.appendChild(label_list)
-    comment = doc.createElement("comment")
-    head.appendChild(comment)
-
-    body = doc.createElement("body")
-    entry_xml.appendChild(body)
-
-    sense_list = doc.createElement("senseList")
-    body.appendChild(sense_list)
-
-    sense = doc.createElement("sense")
-    sense_list.appendChild(sense)
-
-    sense_label_list = doc.createElement("labelList")
-    sense.appendChild(sense_label_list)
-
-    first_translation = example.translations[0][0] if len(example.translations) > 0 and len(example.translations[0]) > 0 else Translation()
-    first_translation_is_valid = False
-    translation_label_list = doc.createElement("labelList")
-
-    # Add labels to sense if label value isn't kontrastivno or približek else keep them in translation
-    for key, value in first_translation.tags:
-        key, value = export_tag(key, value)
-        label_el = doc.createElement("label")
-        label_list = translation_label_list if value == "kontrastivno" or value == "približek" else sense_label_list
-
-        label_el.textContent = value
-        label_el.setAttribute('type', key)
-
-        label_list.appendChild(label_el)
-
-    # Set definition as explanation if explanation in slo
-    definition_list = doc.createElement("definitionList")
-    sense.appendChild(definition_list)
-    for explanation in first_translation.explanationList:
-        if explanation.language == "slo":
-            definition = doc.createElement("definition")
-            definition.setAttribute("type", "indicator")
-            definition.textContent = explanation.value
-            definition_list.appendChild(definition)
-            first_translation.explanationList.remove(explanation)
-
-    translation_container_list = doc.createElement("translationContainerList")
-    sense.appendChild(translation_container_list)
-
-    translation_container = doc.createElement("translationContainer")
-
-    if len(translation_label_list) > 0:
-        translation_container.appendChild(translation_label_list)
-
-    if first_translation.translation is not "":
-        translation = doc.createElement("translation")
-        translation_container.appendChild(translation)
-
-        translation.textContent = first_translation.translation
-        translation.setAttribute("targetLang", first_translation.targetLang)
-
-        if first_translation.audio:
-            translation.setAttribute("audio", first_translation.audio)
-
-        if first_translation.source:
-            translation.setAttribute("source", first_translation.source)
-        first_translation_is_valid = True
-
-    if len(first_translation.explanationList) > 0 :
-        explanation_list = _export_explanation_list(doc, first_translation.explanationList)
-        translation_container.appendChild(explanation_list)
-        first_translation_is_valid = True
-
-    if first_translation_is_valid:
-        translation_container_list.appendChild(translation_container)
-
-    example.translations[0] = example.translations[0][1:] if len(example.translations) > 0 and len(example.translations[0]) > 0 else example.translations[0]
-    export_translation_list(doc, example, translation_container_list)
-    if other_examples is not None:
-        example_container_list = doc.createElement("exampleContainerList")
-        sense.appendChild(example_container_list)
-
-        for example in other_examples:
-            example_container = example.export(doc)
-            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 doc

src/lib/structure_conversions.py

@@ -24,33 +24,32 @@ 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[6].strip()
+        vto_id = line[4].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_structure, vto_id))
+        structure_conversions.append((__new__(RegExp(vfrom, 'u')), vto_name, vto_id))
         
         
 def convert_structure(structure, type):
     if structure_conversions is None:
         build_structure_conversions()
     
-    for vfrom, vto_name, vto_structure, vto_id in structure_conversions:
+    for vfrom, vto_name, vto_id in structure_conversions:
         match = structure.match(vfrom)
-        # fix for ids 106, 107, 44 which instead matched with 30
+        # fix for ids 65, 66, 67 which instead matched with 64
-        if match and vto_id == '30' and '-s' in type:
+        if match and vto_id == '64' and '-s' in type:
             vto_name = 's0-vp-s0'
-            vto_id = '106'
+            vto_id = '65'
-        elif match and vto_id == '30' and '-g' in type:
+        elif match and vto_id == '64' and '-g' in type:
             vto_name = 'gg-vp-gg'
-            vto_id = '107'
+            vto_id = '66'
-        elif match and vto_id == '30' and '-r' in type:
+        elif match and vto_id == '64' and '-r' in type:
             vto_name = 'r-vp-r'
-            vto_id = '44'
+            vto_id = '67'
 
         if match:
             # we need to remove replace alias here as we want to use javascript's one
@@ -58,7 +57,7 @@ def convert_structure(structure, type):
             result = structure.replace(vfrom, vto_name).strip()
             __pragma__('alias', 'replace', "py_replace")
 
-            return result, vto_structure, vto_id
+            return result, vto_id
     
     window.console.log("Unknown structure: ", structure)
     return 'N/A', '/'

src/message/__init__.py

@@ -1,10 +1,10 @@
 from message.simple_messages import NoReset, Reset, ModalNotOkClose, ClickMessage, DataChgClickMessage, KeyboardPress, NoAction
 from message.translation_edit import EditTranslation, MoveRight, MoveLeft, BinTranslation
 from message.show_messages import ShowEntryLabelsEdit, ShowEditTranslation, ShowSenseLabelEdit, ShowSenseDefinitionEdit, ShowCommentEdit, ShowAddTranslation, ShowExampleEdit, ShowVariantsEdit, ShowHomonymyEdit, ShowRelatedEntriesEdit
-from message.simple_edits import EditSenseLabel, EditSenseDefinition, EditComment, AddSenseLabel, AddSense, AddExampleTranslation, MoveExamplesToSense, AddToLabelList, AddToGenericList, EditVariants, EditHomonymy, EditRelatedEntries, EditEntryLabels, ExampleClusterEdit, ExampleClusterAdd
+from message.simple_edits import EditSenseLabel, EditSenseDefinition, EditComment, AddSenseLabel, AddSense, AddExampleTranslation, DoChosenExamples, AddToLabelList, AddToGenericList, EditVariants, EditHomonymy, EditRelatedEntries, EditEntryLabels, ExampleClusterEdit, ExampleClusterAdd
 from message.show_menu import ShowTranslationMenu, ShowSenseMenu, ShowExampleMenu
 from message.sense_edit import SenseMoveUp, SenseMoveDown, SenseBin, AddMultiwordExample
-from message.example_edit import ExampleAsNewEntry, ExampleMoveUp, ExampleMoveDown, ExampleBin, ExampleRoleChange, ExampleComponentSpace, ExampleComponentAdd, ExampleComponentRemove, EditExampleText, ToggleExamples, ToggleClusters
+from message.example_edit import ExampleMoveUp, ExampleMoveDown, ExampleBin, ExampleRoleChange, ExampleComponentSpace, ExampleComponentAdd, ExampleComponentRemove, EditExampleText, ToggleExamples, ToggleClusters
 from message.delete_messages import DeleteComment, DeleteVariants, DeleteHomonymy, DeleteRelatedEntries, DeleteEntryLabels
 from message.ske_messages import ShowSkeModal, SearchInSkeModal, SkeInsert
 

src/message/common_accessors.py

@@ -4,8 +4,10 @@ from browser import document
 def generic_list_getter():
     result = []
     for input_el in document.getElementsByClassName("list-adder-input"):
-        result_candidate = input_el.value
+        result_candidate = {"value": input_el.value}
-        if result_candidate != "":
+        if input_el.hasAttribute("data-id"):
+            result_candidate.id = int(input_el.getAttribute("data-id"))
+        if result_candidate.value != "":
             result.append(result_candidate)
     return result
 
@@ -13,24 +15,22 @@ def generic_list_getter():
 def double_list_getter(firstParameter, secondParameter, allowEmptyField = False):
     result = []
     for row in document.getElementsByClassName("double-list-row"):
-        firstValue = row.querySelector("." + firstParameter + "-input").value
+        output = {}
-        secondValue = row.querySelector("." + secondParameter + "-input").value
+        output[firstParameter] = row.querySelector("." + firstParameter + "-input").value
+        output[secondParameter] = row.querySelector("." + secondParameter + "-input").value
+        if row.hasAttribute("data-id"):
+            output.id = int(row.getAttribute("data-id"))
 
-        if (allowEmptyField is False and '' in [firstValue, secondValue]):
+        if (allowEmptyField is False and '' in [output[firstParameter], output[secondParameter]]):
             continue
 
-        if (allowEmptyField is True and all('' == value or value.isspace() for value in [firstValue, secondValue])):
+        if (allowEmptyField is True and all('' == value or value.isspace() for value in [output[firstParameter], output[secondParameter]])):
             continue
 
-        result.append({firstParameter: firstValue, secondParameter: secondValue})
+        result.append(output)
 
     return result
 
-def definitions_getter():
-    result = {}
-    result["indicator"] = document.getElementById("indicator-input").value
-    result["explanation"] = document.getElementById("explanation-input").value
-    return result
 
 def label_list_getter():
     result = []
@@ -38,6 +38,7 @@ def label_list_getter():
         ltype = row.querySelector(".label-type")
         lvalue = row.querySelector(".label-value")
         lother = row.querySelector(".label-value-other")
+        idx = int(row.getAttribute("data-id")) if row.hasAttribute("data-id") else -1
 
         if lother is None:
             continue
@@ -49,7 +50,7 @@ def label_list_getter():
         if not value:
             continue
 
-        result.append((ltype.textContent, value))
+        result.append((ltype.textContent, value, idx))
 
     kontrastivno = document.getElementById("kontrastivno-input").checked;
     if kontrastivno:

src/message/delete_messages.py

@@ -21,7 +21,9 @@ class DeleteRelatedEntries(DeleteVariants):
 
 class DeleteHomonymy(NoReset):
     def update_model(self, model):
-        for el in document.getElementsByClassName("list-adder-input"):
+        for el in document.getElementsByClassName("name-input"):
+            el.value = ""
+        for el in document.getElementsByClassName("value-input"):
             el.value = ""
 
 

src/message/example_edit.py

@@ -3,10 +3,6 @@ from message.simple_messages import DataChgClickMessage, ClickMessage, NoReset
 from message.message import Message
 from model.example import Example, ComponentLexeme
 from model.sense import Sense
-from model.entry import Entry
-from model.model import Model
-import lib.screenful as screenful
-from export import export_to_xml, export_example_to_entry_xml
 
 
 
@@ -17,17 +13,6 @@ def _get_example_idx(example, model):
                 return (sense, eidx)
 
 
-class ExampleAsNewEntry(ClickMessage):
-    def update_model(self, model):
-        example = self.get_arg(0, Example)
-        entry_xml = export_example_to_entry_xml(example)
-        new_entry = Entry()
-        new_entry.import_xml(entry_xml)
-
-        new_model = Model()
-        new_model.entry = new_entry
-        screenful.screenful().Editor['new'](None, export_to_xml(new_model))
-
 class ExampleMoveUp(DataChgClickMessage):
     def update_model(self, model):
         example = self.get_arg(0, Example)
@@ -75,7 +60,7 @@ class EditExampleText(Message):
         if example.newly_created:
             example.newly_created = False
             sense.examples.append(example)
-
+        console.log(example)
         idx = 0
         for txt in document.getElementsByClassName("example-component-text"):
             example.components[idx].text = txt.value

src/message/sense_edit.py

@@ -18,10 +18,15 @@ class SenseMoveUp(DataChgClickMessage):
         assert(sidx >= 0)
         if sidx == 0:
             return
+#         if sense.original_idx >= 0:
+#             if model.entry.senses[sidx - 1].original_idx >= 0:
+#                 original_parent = model.entry.original_xml.querySelector("body senseList")
+#                 original_parent.insertBefore(original_parent.children[sidx], original_parent.children[sidx - 1])
+#                 model.entry.senses[sidx].original_idx, model.entry.senses[sidx - 1].original_idx = model.entry.senses[sidx - 1].original_idx, model.entry.senses[sidx].original_idx
+#             else:
 
         model.entry.senses[sidx], model.entry.senses[sidx - 1] = model.entry.senses[sidx - 1], model.entry.senses[sidx]
 
-
 class SenseMoveDown(DataChgClickMessage):
     def update_model(self, model):
         sense = self.get_arg(0, Sense)
@@ -30,7 +35,10 @@ class SenseMoveDown(DataChgClickMessage):
         assert(sidx >= 0)
         if sidx == len(model.senses) - 1:
             return
-        
+#         if sense.original_idx >= 0 and model.entry.senses[sidx + 1].original_idx >= 0:
+#             original_parent = model.entry.original_xml.querySelector("body senseList")
+#             original_parent.insertBefore(original_parent.children[sidx + 1], original_parent.children[sidx])
+#             model.entry.senses[sidx].original_idx, model.entry.senses[sidx + 1].original_idx = model.entry.senses[sidx + 1].original_idx, model.entry.senses[sidx].original_idx
         model.entry.senses[sidx], model.entry.senses[sidx + 1] = model.entry.senses[sidx + 1], model.entry.senses[sidx]
 
 
@@ -42,6 +50,12 @@ class SenseBin(DataChgClickMessage):
         assert(sidx >= 0)
         model.entry.senses.splice(sidx, 1)
 
+#         if sense.original_idx >= 0:
+#             model.entry.original_xml.querySelectorAll("body senseList sense")[sense.original_idx].remove()
+#             for index, sense in enumerate(model.entry.senses):
+#                 if (sense.original_idx >= 0):
+#                     sense.original_idx = index
+
 
 class AddMultiwordExample(DataChgClickMessage):
     def on_event(self, event):

src/message/show_menu.py

@@ -58,20 +58,10 @@ class ShowExampleMenu(KeyPlusClickMessage):
     def update_model_default(self, model):
         example = self.get_arg(0, Example)
         
-        # if some are chosen, then show modal for choosing actions
+        # if some are chosen, then show modal for choosing senses
         if len(model.chosen_examples) > 0 and example in model.chosen_examples:
             chosen_examples = model.chosen_examples
-            multiword_example = False
+            model.modal_set(lambda: modals.do_chosen_examples(chosen_examples, model.entry))
-
-            for chosen_example in chosen_examples:
-                if chosen_example.is_multiword():
-                    if multiword_example is False:
-                        multiword_example = chosen_example
-                    else:
-                        multiword_example = False
-                        break
-
-            model.modal_set(lambda: modals.do_chosen_examples(chosen_examples, model, multiword_example))
         else:
             model.menu_location = self.menu_location
             model.menu_target = example

src/message/show_messages.py

@@ -16,7 +16,6 @@ class ShowSenseLabelEdit(ClickMessage):
 class ShowSenseDefinitionEdit(ClickMessage):
     def update_model(self, model):
         model.sense = self.get_arg(0, Sense)
-        model.sense.make_copy()
         model.modal_set(lambda: modals.edit_sense_definition(model.sense))
 
 

src/message/simple_edits.py

@@ -17,6 +17,14 @@ class EditSenseLabel(Message):
         sense = self.get_arg(0, Sense)
         sense.labels = common_accessors.label_list_getter()
 
+        keptIds = [entry[2] for entry in sense.labels]
+        for index, entry in enumerate(sense.original_xml.querySelectorAll("labelList label")):
+                    if (index not in keptIds):
+                        entry.remove()
+
+        for index, entry in enumerate(sense.labels):
+                    if (entry[2] >= 0):
+                        entry[2] = index
 
 class AddToGenericList(NoReset):
     def update_model(self, model):
@@ -43,49 +51,22 @@ class AddToLabelList(NoReset):
 class AddSense(Message):
     def update_model(self, model):
         sense = Sense()
-        sense.definitions = [{"type": "indicator", "value": "Nov pomen"}]
+        sense.definitions.append({"type": "indicator", "value": "New Sense"})
         model.entry.senses.append(sense)
 
 
-class EditSenseDefinition(Message):
+class EditSenseDefinition(QuestionMessage):
     def update_model(self, model):
         sense = self.get_arg(0, Sense)
-        definitions_values = common_accessors.definitions_getter()
+        sense.definitions[0].value = self.new_text
-        indicator = None
-        explanation = None
 
-        for x in sense.definitions:
-            if indicator is None and x["type"] == "indicator":
-                indicator = x
-                if explanation is not None:
-                    break
-            if explanation is None and x["type"] == "explanation":
-                explanation = x
-                if indicator is not None:
-                    break
-
-        if definitions_values["indicator"] != "":
-            if indicator is None:
-                indicator = {"type": "indicator"}
-                sense.definitions.append(indicator)
-            indicator["value"] = definitions_values["indicator"]
-        elif indicator is not None:
-            sense.definitions.remove(indicator)
-
-        if definitions_values["explanation"] != "":
-            if explanation is None:
-                explanation = {"type": "explanation"}
-                sense.definitions.append(explanation)
-            explanation["value"] = definitions_values["explanation"]
-        elif explanation is not None:
-            sense.definitions.remove(explanation)
 
 class EditComment(QuestionMessage):
     def update_model(self, model):
         model.entry.comment = self.new_text
 
 
-class MoveExamplesToSense(Message):
+class DoChosenExamples(Message):
     def update_model(self, model):
         chosen_examples = self.get_arg(0, list)
 
@@ -113,23 +94,36 @@ class MoveExamplesToSense(Message):
 class EditVariants(Message):
     def update_model(self, model):
         variants = common_accessors.generic_list_getter()
+        update_entries(variants, "head variantList variant", model)
         model.entry.variants = variants
 
 class EditHomonymy(Message):
     def update_model(self, model):
         homonymy = common_accessors.double_list_getter("value", "name")
+
+        update_entries(homonymy, "head headword homonymy homonymyFeature", model)
+
         model.entry.homonymy = homonymy
 
 
 class EditRelatedEntries(Message):
     def update_model(self, model):
         related_entries = common_accessors.generic_list_getter()
+        update_entries(related_entries, "head relatedEntryList relatedEntry", model)
         model.entry.related_entries = related_entries
 
 
 class EditEntryLabels(Message):
     def update_model(self, model):
         labels = common_accessors.label_list_getter()
+        keptIds = [entry[2] for entry in labels]
+        for index, entry in enumerate(model.entry.original_xml.querySelectorAll("labelList label")):
+                    if (index not in keptIds):
+                        entry.remove()
+
+        for index, entry in enumerate(labels):
+                    if (entry[2] >= 0):
+                        entry[2] = index
         model.entry.labels = labels
 
 
@@ -145,3 +139,13 @@ class ExampleClusterAdd(DataChgClickMessage):
         example = self.get_arg(0, Example)
         example.set_cluster(ExampleClusters.first_empty_cluster())
 
+
+def update_entries(updated_list, query, model):
+    keptIds = [entry.id for entry in updated_list]
+    for index, entry in enumerate(model.entry.original_xml.querySelectorAll(query)):
+                if (index not in keptIds):
+                    entry.remove()
+
+    for index, entry in enumerate(updated_list):
+                if (entry.id >= 0):
+                    entry.id = index

src/message/ske_messages.py

@@ -59,8 +59,7 @@ class SkeCollocation:
     def __init__(self, data):
         self.word = data.word
         self.frequency = data.count
-        self.gramrel = data.gramrel
+        self.structure_name, self.structure_id = convert_structure(data.gramrel, data.lempos)
-        self.structure_name, self.structure, self.structure_id = convert_structure(data.gramrel, data.lempos)
         
         self.other = {"score": data.score, "cm": data.cm}
 
@@ -103,28 +102,13 @@ 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) < 5:
+            if len(self._args) < 4:
                 self.add_arg(None)
             super().on_event(event)
         
@@ -132,20 +116,18 @@ 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, ske_pos_query)
+        next_message = msg(SkeModal, page_num, search_term, ske_index)
         
         # could be none if empty
-        data = self.get_arg(4)
+        data = self.get_arg(3)
         
         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:
@@ -154,36 +136,15 @@ 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 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, ske_pos_query)
+                match_gf2_examples(data, page_num, search_term, ske_index)
-            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))
     
@@ -194,7 +155,7 @@ class SkeModal(ClickMessage):
 class SkeModalGf2Update(SkeModal):
     def on_event(self, event):
         response_data = window.JSON.parse(event.target.response)
-        data = self.get_arg(4)
+        data = self.get_arg(3)
         
         data_dict = {}
         for example in data:
@@ -230,7 +191,6 @@ 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)
 
 
@@ -269,7 +229,7 @@ class SkeInsert(DataChgClickMessage):
     def _as_corpus_example(self, example):
         new_example = Example()
         new_example.inner = CorpusExample()
-        new_example.inner.other_attributes["exampleId"] = example.s_id
+        new_example.inner.other_attributes["example_id"] = example.s_id
         new_example.inner.cluster = ExampleClusters.first_empty_cluster()
         
         lex_left = ComponentLexeme()
@@ -278,7 +238,7 @@ class SkeInsert(DataChgClickMessage):
         
         lex_mid = ComponentLexeme()
         lex_mid.text = example["mid"]
-        lex_mid.role = "headword"
+        lex_mid.role = "collocation"
         
         lex_right = ComponentLexeme()
         lex_right.text = example["right"]
@@ -297,45 +257,17 @@ class SkeInsert(DataChgClickMessage):
         new_collocation.inner.other_attributes["frequency"] = example.frequency
         new_collocation.inner.type = "collocation"
         
-        headword = document.getElementById("ske-search").value       
+        lex_left = ComponentLexeme()
-        lexemes = []
+        lex_left.text = ""
-        structure_name = example.structure_name.split("-")
+        lex_left.role = None
-        gramrel = example.gramrel.split("_")
-        structure = example.structure.split(" ")
-        structure.append("") # Bad fix: we have to add something for structure l-gg-ggn
         
-        for i in range(len(structure_name)):
+        lex_mid = ComponentLexeme()
-            lex = ComponentLexeme()
+        lex_mid.text = example.word
-            structure[i] = structure[i].replace("Inf-", "")
+        lex_mid.role = "collocation"
         
-            # take care of negations "ne"
+        lex_right = ComponentLexeme()
-            if "Neg-" in structure[i]:
+        lex_right.text = ""
-                structure[i] = structure[i].replace("Neg-", "")
+        lex_right.role = None
-                negation_flag = True
-                n_lex = ComponentLexeme()
-                n_lex.text = "ne"
-                n_lex.role = "other"
-                lexemes.append(n_lex)
         
-            if structure[i] is "":
+        new_collocation.components.extend([lex_left, lex_mid, lex_right])
-                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

@@ -14,6 +14,7 @@ class EditTranslation(DataChgClickMessage):
         self.old_cluster_idx = self.get_arg(1, int)
 
         self.translation.translation = document.getElementById("etv").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 = []
@@ -21,10 +22,19 @@ class EditTranslation(DataChgClickMessage):
             explanation = Explanation()
             explanation.value = entry.value
             explanation.language = entry.language
+            explanation.original_xml = entry.original_xml if entry.original_xml != None else None
             self.translation.explanationList.append(explanation)
+
         # common_accessors.label_list_getter()
         self.translation.tags = common_accessors.label_list_getter()
+        keptIds = [entry[2] for entry in self.translation.tags]
+        for index, entry in enumerate(self.translation.original_xml.querySelectorAll("labelList label")):
+                    if (index not in keptIds):
+                        entry.remove()
 
+        for index, entry in enumerate(self.translation.tags):
+                    if (entry[2] >= 0):
+                        entry[2] = index
         # check if empty, remove!
         if self.translation.is_empty():
             model.entry.remove_translation(self.translation)

src/model/data.py

@@ -63,7 +63,7 @@ class Data:
             return None
     
     def overwrite_with_copy(self):
-        for key, value in dict(self._copy).items():
+        for key, value in dict(self).items():
             # skip functions and _copy
             if key == "_copy" or type(value) is None:
                 continue

src/model/entry.py

@@ -26,7 +26,8 @@ class Entry(Data):
         self.original_xml = None
 
     def import_xml(self, entry_xml):
-        self.original_xml = entry_xml.cloneNode(True)
+        console.log(entry_xml)
+        self.original_xml = entry_xml
         status = entry_xml.querySelector("head status")
 
         headword = entry_xml.querySelector("head headword lemma")
@@ -39,22 +40,14 @@ class Entry(Data):
         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")]
+        self.variants = [{"value": v.textContent, "id": index} for index, v in enumerate(entry_xml.querySelectorAll("head variantList variant"))]
-        self.homonymy = [{"value": v.textContent, "name": v.getAttribute("name")} for v in entry_xml.querySelectorAll("head headword homonymy homonymyFeature ")]
+        self.homonymy = [{"value": v.textContent, "name": v.getAttribute("name"), "id": index} for index, v in enumerate(entry_xml.querySelectorAll("head headword homonymy homonymyFeature "))]
-        self.related_entries = [re.textContent for re in entry_xml.querySelectorAll("head relatedEntryList relatedEntry")]
+        self.related_entries = [{"value": re.textContent, "id": index} for index, re in enumerate(entry_xml.querySelectorAll("head relatedEntryList relatedEntry"))]
-        lex_units = entry_xml.querySelectorAll("lexical_unit lexeme,lexicalUnit lexeme")
+
-        lex_unit_parent = entry_xml.querySelector("lexicalUnit")
+        lex_unit = entry_xml.querySelector("lexical_unit lexeme,lexicalUnit lexeme")
-        self.lexical_unit['lexemes'] = []
+        if lex_unit:
-        if lex_unit_parent and lex_unit_parent.hasAttribute("id"):
+            self.lexical_unit['id'] = lex_unit.getAttribute("lexical_unit_lexeme_id")
-            self.lexical_unit['id'] = lex_unit_parent.getAttribute('id')
+            self.lexical_unit['text'] = lex_unit.textContent
-        self.lexical_unit['type'] = lex_unit_parent.getAttribute("type") if lex_unit_parent and lex_unit_parent.hasAttribute(
-            "type") else "single"
-        for unit in lex_units:
-            lexical_unit = {}
-            if unit.hasAttribute("lexical_unit_lexeme_id"):
-                lexical_unit['id'] = unit.getAttribute("lexical_unit_lexeme_id")
-            lexical_unit['text'] = unit.textContent
-            self.lexical_unit['lexemes'].append(lexical_unit)
 
         measure = entry_xml.querySelector("measureList measure")
         if measure:
@@ -62,12 +55,13 @@ class Entry(Data):
             self.measure["type"] = measure.getAttribute("type")
             self.measure["text"] = measure.textContent
 
-        self.labels = import_label_list("head labelList label", entry_xml)
+        self.labels = import_label_list("head labelList label", self.original_xml)
 
         for i, sense_xml in enumerate(entry_xml.querySelectorAll("body senseList sense")):
             sense = Sense()
             sense.import_xml(sense_xml, i)
             self.senses.append(sense)
+            sense_xml.remove()
 
 
     def view(self, model):
@@ -104,7 +98,7 @@ class Entry(Data):
         if len(self.variants) == 0:
             view_buttons.append(buttons[0])
         else:
-            view_table.append((buttons[0], ", ".join(self.variants)))
+            view_table.append((buttons[0], ", ".join(v.value for v in self.variants)))
 
         if len(self.homonymy) == 0:
             view_buttons.append(buttons[4])
@@ -114,18 +108,12 @@ class Entry(Data):
         if len(self.related_entries) == 0:
             view_buttons.append(buttons[1])
         else:
-            view_table.append((buttons[1], ", ".join(self.related_entries)))
+            view_table.append((buttons[1], ", ".join(re.value for re in self.related_entries)))
 
         if len(self.labels) == 0:
             view_buttons.append(buttons[2])
         else:
-            labels = ""
+            labels = ", ".join([clean_label(val) for _, val in self.labels])
-            for key, val in self.labels:
-                if key == "SKRIJ POMEN" and val == "Skrij":
-                    labels = "SKRIJ POMEN, " + labels
-                else:
-                    labels += clean_label(val) + ", "
-            labels = labels[:-2]
             view_table.append((buttons[2], labels))
 
         if self.comment == "":
@@ -155,4 +143,3 @@ class Entry(Data):
                     if translation in cluster:
                         cluster.remove(translation)
                         return
-

src/model/example/component_lexeme.py

@@ -11,8 +11,10 @@ class ComponentLexeme(Data):
         self.text = ""
         self.role = ""
         self.no_space = False
+        self.original_xml = None
 
     def import_xml(self, xml):
+        self.original_xml = xml.cloneNode(True)
         if xml.nodeName == "#text":
             self.text = xml.data
             self.role = None
@@ -25,6 +27,7 @@ class ComponentLexeme(Data):
             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)
+        xml.remove()
 
     def isValid(self):
         return len(self.text) > 0
@@ -32,7 +35,8 @@ class ComponentLexeme(Data):
     def export(self, doc):
         if self.role is None:
             return doc.createTextNode(self.text)
-        result = doc.createElement("comp")
+        result = self.original_xml if self.original_xml is not None else doc.createElement("comp")
+
         result.setAttribute("role", self.role)
         result.textContent = self.text
 

src/model/example/corpus_example.py

@@ -3,19 +3,17 @@ from lib.snabbdom import h
 class CorpusExample:
     def __init__(self):
         self.other_attributes = {}
+        self.original_xml = None
     
     def import_xml(self, example_xml):
-        for oth_attr in ["exampleId", "modified", "lexical_unit_id", "audio"]:
+        for oth_attr in ["example_id", "modified", "lexical_unit_id", "audio"]:
             if example_xml.hasAttribute(oth_attr):
                 self.other_attributes[oth_attr] = example_xml.getAttribute(oth_attr)
-            
+        self.original_xml = example_xml
-            # this is a quick fix. when all data has been updated from @example_id to @exampleId, you can remove this
+        example_xml.remove()
-            if oth_attr is "exampleId":
-                if example_xml.hasAttribute("example_id"):
-                    self.other_attributes[oth_attr] = example_xml.getAttribute("example_id")
 
     def export(self, doc, modified):
-        result = doc.createElement("corpusExample")
+        result = self.original_xml if self.original_xml is not None else doc.createElement("corpusExample")
         if modified:
             result.setAttribute("modified", "true")
             

src/model/example/example.py

@@ -13,6 +13,7 @@ from model.example_clusters import ExampleClusters
 
 class Example(Data):
     def __init__(self):
+        self.original_xml = None
         self.translations = []
         self.inner = None
         self.components = []
@@ -22,8 +23,6 @@ class Example(Data):
     # removes space from last component if multiword example
     def check_multiword_components(self):
         if self.is_multiword():
-            # .no_space breaks if it's undefined
-            if self.components[len(self.components) - 1] != None:
             self.components[len(self.components) - 1].no_space = ComponentLexeme.LAST_COMPONENT_SPACE
 
     @staticmethod
@@ -43,20 +42,20 @@ class Example(Data):
 
     def import_xml(self, example_xml):
         self.translations = from_container_list(example_xml.querySelectorAll("translationContainerList translationContainer"))
-
+        self.original_xml = example_xml.cloneNode(True)
         if example_xml.hasAttribute("modified"):
             self.edited = example_xml.getAttribute("modified") == "true"
 
-        inner_xml = example_xml.querySelector("corpusExample")
+        inner_xml = self.original_xml.querySelector("corpusExample")
         if inner_xml is not None:
             self.inner = CorpusExample()
         else:
-            inner_xml = example_xml.querySelector("multiwordExample")
+            inner_xml = self.original_xml.querySelector("multiwordExample")
             self.inner = MultiwordExample()
 
         self.inner.import_xml(inner_xml)
 
-        for idx, comp_xml in enumerate(inner_xml.childNodes):
+        for idx, comp_xml in enumerate(self.inner.original_xml.childNodes):
             comp = ComponentLexeme()
             comp.import_xml(comp_xml)
             if comp.isValid():
@@ -64,11 +63,10 @@ class Example(Data):
 
         self.check_multiword_components()
 
-    def export(self, doc):
+    def export(self, doc, xml_parent):
         self.check_multiword_components()
-
+        result = self.original_xml if self.original_xml != None else doc.createElement("exampleContainer")
-        result = doc.createElement("exampleContainer")
+        xml_parent.appendChild(result)
-
         inner = self.inner.export(doc, self.edited)
         # TODO: bad quick fix
         for comp in self.components:

src/model/example/multiword_example.py

@@ -6,8 +6,10 @@ class MultiwordExample:
         self.other_attributes = {}
         self.cluster = -1
         self.type = None
+        self.original_xml = None
     
     def import_xml(self, example_xml):
+        self.original_xml = example_xml.cloneNode(True)
         for oth_attr in ["lexical_unit_id", "structure_id", "structureName", "audio", "frequency", "logDice"]:
             if example_xml.hasAttribute(oth_attr):
                 self.other_attributes[oth_attr] = example_xml.getAttribute(oth_attr)
@@ -17,6 +19,9 @@ class MultiwordExample:
         if example_xml.hasAttribute("type"):
             self.type = example_xml.getAttribute("type")
 
+
+        example_xml.remove()
+
     @staticmethod
     def _determine_cluster_number(example_xml):
         if not example_xml.hasAttribute("cluster"):
@@ -27,8 +32,8 @@ class MultiwordExample:
             return cluster
             
     def export(self, doc, _modified):
-        result = doc.createElement("multiwordExample")
+        result = self.original_xml if self.original_xml is not None else doc.createElement("multiwordExample")
-            
+        # result = doc.createElement("multiwordExample")
         for key, value in self.other_attributes.items():
             result.setAttribute(key, value)
         

src/model/explanation.py

@@ -7,14 +7,15 @@ class Explanation(Data):
     def __init__(self):
         self.value = ""
         self.language = ""
+        self.original_xml = None
 
-    def import_dom(self, explanation_dom):
+    def import_dom(self, explanation_xml):
-
+        self.original_xml = explanation_xml.cloneNode(True)
-        self.value = explanation_dom.textContent if explanation_dom else ""
+        self.value = explanation_xml.textContent if explanation_xml else ""
-        self.language = explanation_dom.getAttribute("language") if explanation_dom.hasAttribute("language") else ""
+        self.language = explanation_xml.getAttribute("language") if explanation_xml.hasAttribute("language") else ""
 
     def export(self, doc):
-        result = doc.createElement("explanation")
+        result = self.original_xml if self.original_xml != None else doc.createElement("explanation")
         result.textContent = self.value
         if self.language != "": result.setAttribute('language', self.language)
 

src/model/sense.py

@@ -11,7 +11,7 @@ from view.utils import clean_label
 class Sense(Data):
     def __init__(self):
         self.original_idx = -1
-        self.id = None
+        self.original_xml = None
         self.definitions = []
         self.labels = []
         self.translations = []
@@ -19,39 +19,41 @@ class Sense(Data):
 
     def import_xml(self, sense_xml, idx):
         self.original_idx = idx
-        self.id = sense_xml.getAttribute("id") if sense_xml.hasAttribute("id") else None
+        self.original_xml = sense_xml.cloneNode(True)
 
-        self.definitions = [{"value": v.textContent, "type": v.getAttribute("type")} for v in sense_xml.querySelectorAll("definitionList definition")]
+        for definition in self.original_xml.querySelectorAll("definitionList definition"):
+            definition_object = {}
+            definition_object.type = definition.getAttribute("type")
+            definition_object.value = definition.textContent
+            definition_object.original_xml = definition
+            definition.remove()
+            self.definitions.append(definition_object)
 
-        self.labels = import_label_list("sense > labelList label", sense_xml)
+        self.labels = import_label_list("sense > labelList label", self.original_xml)
         self.translations = from_container_list(
-            sense_xml.querySelectorAll('sense > translationContainerList translationContainer'))
+            self.original_xml.querySelectorAll('sense > translationContainerList translationContainer'))
-        for example_xml in sense_xml.querySelectorAll("exampleContainerList exampleContainer"):
+        for example_xml in self.original_xml.querySelectorAll("exampleContainerList exampleContainer"):
             example = Example()
             example.import_xml(example_xml)
             self.examples.append(example)
+            example_xml.remove()
+
+        console.log(self.original_xml)
 
 
     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]
-        indicator = None
-        explanation = None
-        for x in self.definitions:
-            if indicator is None and x["type"] == "indicator":
-                indicator = x.value
-            if explanation is None and x["type"] == "explanation":
-                explanation = x.value
 
         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-definition", { "on": { "click": M.msg(M.ShowSenseDefinitionEdit, self) }}, indicator),
+            h("span.sense-definition", { "on": { "click": M.msg(M.ShowSenseDefinitionEdit, self) }}, ", ".join(d.value for d in self.definitions)),
-            h("div", {}, "Razlaga: " + explanation) if explanation else None,
             h("div", {}, View.view_translations(self.translations, self, model)),
             h("div", {}, examples)])])
         return result

src/model/tags.py

@@ -8,10 +8,7 @@ TAGS = {
 	  "latinsko": [],
 	  "razmerje": ["približek", "sinonim", "antonim"],
 	  "semantično": [],
-      "kontekstualna": [],
+	  "English-full": []
-	  "Polno angleško": [],
-      "Blagovna znamka": [],
-      "SKRIJ POMEN": ["Skrij"]
 }
 
 SLO2ENG_TAGS = {
@@ -25,10 +22,7 @@ SLO2ENG_TAGS = {
     "latinsko": "latin",
     "razmerje": "relation",
     "semantično": "semantic",
-    "kontekstualna": "context",
+    "English-full": "Polno angleško"
-    "Polno angleško": "English-full",
-    "Blagovna znamka": "trademark",
-    "SKRIJ POMEN": "hide-sense",
 }
 
 ENG2SLO_TAGS = { value: key for key, value in SLO2ENG_TAGS.items() }
@@ -41,12 +35,12 @@ STYLE_SECTIONS = [("registrske", "register"),
 
 def import_label_list(selector, xml_element):
     result = []
-    for tag_xml in xml_element.querySelectorAll(selector):
+    for index, tag_xml in enumerate(xml_element.querySelectorAll(selector)):
         t_type = tag_xml.getAttribute("type")
         t_value = tag_xml.textContent
 
         t_type, t_value = import_tag(t_type, t_value)
-        result.append((t_type, t_value))
+        result.append((t_type, t_value, index))
     return result
 
 
@@ -75,9 +69,6 @@ def import_tag(key, value):
     # this should not happen, but maybe there was a bug...
     value = value.replace("--", "").strip()
 
-    if key == "SKRIJ POMEN" and value == "true":
-        value = "Skrij"
-
     for tag_key in TAGS.keys():
         for possible_value in TAGS[tag_key]:
             if value == possible_value or "-- " + value == possible_value:
@@ -102,8 +93,7 @@ def export_tag(key, value):
 
     else:
         key = SLO2ENG_TAGS[key]
-    if key == "hide-sense":
+
-        value = "true"
     value = value.replace("--", "").strip()
     return key, value
 

src/model/translation.py

@@ -20,6 +20,8 @@ def from_container_list(translation_list_container_xml):
         t = Translation()
         t.import_xml(translation_xml)
         translations.append((num_cluster, t))
+        translation_xml.remove()
+
 
     result = [[] for _ in range(max_num_cluster)]
     for clusterNum, translation in translations:
@@ -30,6 +32,7 @@ def from_container_list(translation_list_container_xml):
 
 class Translation(Data):
     def __init__(self, translation_xml):
+        self.original_xml = None
         self.translation = ""
         self.source = ""
         self.targetLang = ""
@@ -39,6 +42,7 @@ class Translation(Data):
 
     def import_xml(self, translation_xml):
         translation = translation_xml.querySelector("translation")
+        self.original_xml = translation_xml.cloneNode(True)
 
         if translation:
             self.translation = translation.textContent
@@ -46,13 +50,13 @@ class Translation(Data):
             self.targetLang = translation.getAttribute("targetLang")  if translation.hasAttribute("targetLang") else ""
             self.audio = translation.getAttribute("audio")  if translation.hasAttribute("audio") else ""
 
-        explanationList = translation_xml.querySelectorAll("explanationList explanation")
+        explanationList = self.original_xml.querySelectorAll("explanationList explanation")
         for explanation_dom in explanationList:
             explanation = Explanation()
             explanation.import_dom(explanation_dom)
             self.explanationList.append(explanation)
-
+            explanation_dom.remove()
-        self.tags = import_label_list("labelList label", translation_xml)
+        self.tags = import_label_list("labelList label", self.original_xml)
 
     def view(self, model):
         elements = []

src/view/modal_templates.py

@@ -11,7 +11,7 @@ def modal_template(content, title, msg, delete_msg=None):
     if msg is not None:
         footer.append(h("a#modal-ok.button", {"on": {"click":  message.msg(*msg)}}, "OK"))
 
-    footer.append(h("label.button.dangerous", {"on": {"click": reset}}, "Prekliči"))
+    footer.append(h("label.button.dangerous", {"on": {"click": reset}}, "Cancel"))
     if delete_msg is not None:
         footer.append(h("label.button.warning.modal-delete", {"on": {"click": message.msg(*delete_msg)}}, "🗑"))
 
@@ -42,43 +42,19 @@ def question(question, current_value):
 def generic_list_editor(title, element_list_getter):
     content = [h("p", {}, title)]
     for slabel in element_list_getter():
+        idAttr = {"data-id": slabel.id} if slabel.id >= 0 else {}
         content.append(h("label", {}, [
-            h("input.list-adder-input", {"props": {"type": "text", "value": slabel}}, "")]))
+            h("input.list-adder-input", {"props": {"type": "text", "value": slabel.value or slabel}, "attrs": idAttr}, "")]))
+
+        console.log(content)
     content.append(h("button", {"on": {"click": message.msg(message.AddToGenericList, element_list_getter)}}, "+"))
     return content
 
-def generic_key_value_editor(title, element_list_getter, key, value = "value"):
-    def split_line2(left, right):
-        cls = "flex.two{}".format(".double-list-row")
-        return h("div.{}".format(cls), {}, [
-            h("div.half", {}, left), h("div.half", {}, right)])
-    content = [h("p", {}, title)]
-    for i, element in enumerate(element_list_getter()):
-        keys = []
-        values = []
-        keys.append(h("label", {"attrs": {"for": i}}, key.capitalize() + ":"))
-        keys.append(h("input." + key + "-input", {"props": {"type": "text", "value": element[key], "id": i}}, ""))
-        values.append(h("label", {"attrs": {"for": i + "-value"}}, "Value:"))
-        values.append(
-            h("input.value-input", {"props": {"type": "text", "value": element[value], "id": i + "-value"}}, ""))
-        content.append(split_line2(keys, values))
-    content.append(h("button", {"on": {"click": message.msg(message.AddToGenericList, element_list_getter)}}, "+"))
-    return content
-
-def sense_definitions_editor(type_value, explanation_value):
-    type_props = {"value": type_value, "type": "text"}
-    explanation_props = {"value": explanation_value, "type": "text"}
-    return [
-        h("span", {}, "Indikator:"),
-        h("label", {}, [h("input#indicator-input", {"props": type_props}, "")]),
-        h("span", {}, "Razlaga:"),
-        h("label", {}, [h("input#explanation-input", {"props": explanation_props}, "")])
-    ]
-
 def homonymy_editor(title, current_labels):
-    def split_line2(left, right):
+    def split_line2(left, right, labelId):
         cls = "flex.two{}".format(".double-list-row")
-        return h("div.{}".format(cls), {}, [
+        isId = {"attrs": {"data-id": labelId}} if labelId >= 0 else {}
+        return h("div.{}".format(cls), isId, [
             h("div.half", {}, left), h("div.half", {}, right)])
 
     content = [h("p", {}, title)]
@@ -86,19 +62,20 @@ def homonymy_editor(title, current_labels):
         name = []
         value = []
         name.append(h("label", {"attrs": {"for": i}}, "Name:"))
-        name.append(h("input.name-input", {"props": {"type": "text", "value": feature["name"], "id": i}}, ""))
+        name.append(h("input.name-input", {"props": {"type": "text", "value": feature["name"], "id": i, "data-id": feature.id}}, ""))
         value.append(h("label", {"attrs": {"for": i + "-value"}}, "Value:"))
         value.append(h("input.value-input", {"props": {"type": "text", "value": feature["value"], "id": i + "-value"}}, ""))
 
-        content.append(split_line2(name, value))
+        content.append(split_line2(name, value, feature.id))
     content.append(h("button", {"on": {"click": message.msg(message.AddToGenericList, current_labels)}}, "+"))
 
     return content
 
 def explanation_editor(title, current_labels):
-    def split_line2(left, right):
+    def split_line2(left, right, labelId):
             cls = "flex.two{}".format(".double-list-row")
-            return h("div.{}".format(cls), {}, [
+            isId = {"attrs": {"data-id": labelId}} if labelId >= 0 else {}
+            return h("div.{}".format(cls), isId, [
                 h("div.four-fifth", {}, left), h("div.fifth", {}, right)])
 
     content = [h("p", {}, title)]
@@ -110,7 +87,7 @@ def explanation_editor(title, current_labels):
         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(split_line2(value, language, explanation.id))
     content.append(h("button", {"on": {"click": message.msg(message.AddToGenericList, current_labels)}}, "+"))
 
     return content
@@ -118,12 +95,13 @@ def explanation_editor(title, current_labels):
 
 
 def label_list_editor(current_labels, add_label_message_class):
-    def split_line3(left, center, right, is_llr=True):
+    def split_line3(left, center, right, labelId, is_llr=True):
+        isId = {"attrs": {"data-id": labelId}} if labelId >= 0 else {}
         cls = "flex.three{}".format(".label-list-row" if is_llr else "")
-        return h("div.{}".format(cls), {}, [
+        return h("div.{}".format(cls), isId, [
             h("span.third", {}, left), h("span.third", {}, center), h("span.third", {}, right)])
 
-    def dropdown_right(label_type, label):
+    def dropdown_right(label_type, label, index):
         left = h("span.label-type", {}, label_type)
 
         options = [h("option", {}, [])]
@@ -132,26 +110,20 @@ def label_list_editor(current_labels, add_label_message_class):
         center = h("select.label-value", {}, options)
 
         right_value = label if label not in TAGS[label_type] else ""
-        if label_type == "Blagovna znamka":
-            right_value = "blagovna znamka"
-        elif label_type == "SKRIJ POMEN":
-            right_value = "Skrij"
-        # right_value = "blagovna znamka" if label_type == 'Blagovna znamka' else right_value
         right = h("input.label-value-other",
                   {"props": {"type": "text", "value": right_value, "placeholder": "drugo"}},
                   [])
 
-        return split_line3(left, center, right)
+        return split_line3(left, center, right, index)
 
     content = []
     kontrastivno = False
-    for key, value in current_labels:
+    for key, value, idx in current_labels:
         # we will show kontrastivno a bit differently
         if value == "kontrastivno":
             kontrastivno = True
             continue
-
+        content.append(dropdown_right(key, value, (idx if idx >= 0 else -1)))
-        content.append(dropdown_right(key, value))
 
     # add a way to get new element to add to tag list
     def get_new_label_type():

src/view/modals.py

@@ -2,11 +2,6 @@ from lib.snabbdom import h
 import message
 from view.modal_templates import *
 from view.utils import show_toggle_cluster_buttons
-from export import export_to_xml, export_example_to_entry_xml
-from update import update
-from model.entry import Entry
-import lib.screenful as screenful
-from model.model import Model
 import model
 
 
@@ -45,7 +40,9 @@ def edit_sense_label(sense):
 
 def edit_example(example, sense):
     example_original = example
-    example = example_original.copy()
+    # example = example_original.deepcopy()
+    # example = copy.deepcopy(example)
+    # example.original_xml = example_original.original_xml.cloneNode(True)
 
     def role_msg(idx, role):
         return message.msg(message.ExampleRoleChange, example_original, idx, role)
@@ -69,7 +66,6 @@ def edit_example(example, sense):
             result.append(h("span.example-component-button.example-component-none",
             {"on": {"click": role_msg(idx, "none")}}, "N"))
 
-        if "-" not in example.inner.other_attributes["structureName"]:
         result.extend([
             h("span.example-component-button",
             {"on": {"click": message.msg(message.ExampleComponentAdd, example_original, idx)}}, "+"),
@@ -78,9 +74,6 @@ def edit_example(example, sense):
 
         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
@@ -109,9 +102,11 @@ def edit_variants(entry):
 
 def edit_homonymy(entry):
     hget = lambda: entry.copy().homonymy
-    content = generic_key_value_editor("Homonymy", hget, "name")
+    console.log(hget)
+    content = homonymy_editor("Homonymy", hget)
     return modal_template(content, "Add or remove homonymy features", (message.EditHomonymy,), (message.DeleteHomonymy,))
 
+
 def edit_related_entries(entry):
     reget = lambda: entry.copy().related_entries
     content = generic_list_editor("Related entries", reget)
@@ -124,57 +119,14 @@ def edit_entry_labels(entry):
 
 
 def edit_sense_definition(sense):
-    indicator = ""
+    return modal_template(question("Edit sense definition", sense.definitions[0].value), "Sense definition", (message.EditSenseDefinition, sense))
-    explanation = ""
-    for x in sense.copy().definitions:
-        if indicator == "" and x["type"] == "indicator":
-            indicator = x.value
-            if explanation is not "":
-                break
-        if explanation == "" and x["type"] == "explanation":
-            explanation = x.value
-            if indicator is not "":
-                break
-
-    content = sense_definitions_editor(indicator, explanation)
-    return modal_template(content, "Definicije pomena", (message.EditSenseDefinition, sense))
 
 
 def edit_comment(comment):
     return modal_template(big_question("Edit comment", comment), "Comment", (message.EditComment,), (message.DeleteComment,))
 
 
-def do_chosen_examples(example_list, model, multiword_example):
+def do_chosen_examples(example_list, entry):
-    if multiword_example is False:
-        return move_examples_to_sense(example_list, model.entry)
-    else:
-        return modal_template([
-            h("button.shyButton", {"on": {"click": (lambda: move_to_view(example_list, model))}}, "Premakni v pomen"),
-            h("button.shyButton", {"on": {"click": (lambda: export_to_new_entry(multiword_example, example_list))}},
-              "Izvozi v novo geslo")], "Izberite željeno akcijo", None)
-
-
-def move_to_view(example_list, model):
-    model.modal_reset()
-    model.modal_set(lambda: move_examples_to_sense(example_list, model.entry))
-    update.view.view(model, True)
-
-
-def export_to_new_entry(multiword_example, example_list):
-    other_examples = []
-    for example in example_list:
-        if example.is_multiword() is False:
-            other_examples.append(example)
-    entry_xml = export_example_to_entry_xml(multiword_example, other_examples if len(example_list) > 0 else None)
-    new_entry = Entry()
-    new_entry.import_xml(entry_xml)
-
-    new_model = Model()
-    new_model.entry = new_entry
-    screenful.screenful().Editor['new'](None, export_to_xml(new_model))
-
-
-def move_examples_to_sense(example_list, entry):
     example_senses = []
     for idx, sense in enumerate(entry.senses):
         for ex in sense.examples:
@@ -185,15 +137,8 @@ def move_examples_to_sense(example_list, entry):
     sense_of_first_example = example_senses[0]
 
     options = [h("p", {}, "Choose sense for examples")]
-
     for idx, sense in enumerate(entry.senses):
-        definition = sense.definitions[0].value
+        text = "{}: {}".format(idx + 1, sense.definitions[0].value)
-        for x in sense.definitions:
-            if x["type"] == "indicator":
-                definition = x.value
-                break
-
-        text = "{}: {}".format(idx + 1, definition)
         id_ = "choose-example-{}".format(idx)
 
         props = {"type": "radio", "name": "choose-example"}
@@ -203,7 +148,8 @@ def move_examples_to_sense(example_list, entry):
         options.append(h("input#{}.checkable-input".format(id_), {"props": props}, []))
         options.append(h("label.checkable", {"attrs": {"for": id_}}, text))
         options.append(h("br", {}, []))
-    return modal_template(options, "Examples picker", (message.MoveExamplesToSense, example_list))
+
+    return modal_template(options, "Examples picker", (message.DoChosenExamples, example_list))
 
 
 def ske_list(search_term, data, page_num, senses, ske_kinds):
@@ -221,12 +167,7 @@ def ske_list(search_term, data, page_num, senses, ske_kinds):
         ske_list_hidden = True
     else:
         list_contents.append(h("span.error", {}, "Something went wrong in SKE: {}".format(data)))
-    definitions = []
+
-    for sense in senses:
-        for x in sense.definitions:
-            if x["type"] == "indicator":
-                definitions.append(x.value)
-                break
     contents = [
         h("div.flex.four", {}, [
             h("select#ske-select.fourth", {}, [
@@ -239,10 +180,6 @@ 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",
@@ -251,6 +188,6 @@ def ske_list(search_term, data, page_num, senses, ske_kinds):
         h("div.flex.three", {}, [
             h("span.third", {}, "Vstavi v:"),
             h("select#ske-sense-select.two-third", {}, [ h("option", {}, "{} {}".format(
-                idx + 1, definition)) for idx, definition in enumerate(definitions)])])]
+                idx + 1, sense.definitions[0].value)) for idx, sense in enumerate(senses)])])]
 
     return modal_template(contents, "SKE", (message.SkeInsert, data))

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, "simple")} }, 
+            { "on": {"click": msg(ShowSkeModal, 1, model.entry.headword, 0)} }, 
             h("svg#ske-img", {
                 "attrs": {
                     "xmlns": "http://www.w3.org/2000/svg",
@@ -98,16 +98,11 @@ class View:
         elif type(menu_target) is Example:
             example = menu_target
             sense = example_sense(example, entry)
-            dom_children = [
+            return h("span.popup-menu", { "style": style }, [
                 h("button.shyButton", { "on": {"click": msg(ShowExampleEdit, example, sense)}}, "✎"),
                 h("button.shyButton", { "on": {"click": msg(ExampleMoveUp, example)}}, "↑"),
                 h("button.shyButton", { "on": {"click": msg(ExampleMoveDown, example)}}, "↓"),
-                h("button.shyButton", { "on": {"click": msg(ExampleBin, example)}}, "🗑")]
+                h("button.shyButton", { "on": {"click": msg(ExampleBin, example)}}, "🗑")])
-
-            if example.is_multiword():
-                dom_children.insert(1, h("button.shyButton", { "on": {"click": msg(ExampleAsNewEntry, example, sense)}}, "Izvozi v novo geslo"))
-
-            return h("span.popup-menu", { "style": style }, dom_children)
         else:
             console.log("Should not be heree!!")