lip -> inflection

--HG-- branch : beta

lip -> inflection
--HG-- branch : beta
janek@kublik
1 parent c001aac9
Showing 28 changed files with 377 additions and 359 deletions
common/static/css/general.css
dictionary/ajax_lexeme_slickgrid.py
dictionary/ajax_lexeme_view.py
dictionary/ajax_prompter.py
dictionary/auto_derivatives.py
dictionary/forms.py
dictionary/management/commands/import_witek.py
dictionary/models.py
dictionary/static/css/inflection_table.css
dictionary/static/css/lexeme_view.css
dictionary/static/js/lexeme-edit.js
dictionary/static/js/lexeme-view.js
dictionary/templates/inflection_tables.html
dictionary/templates/lexeme_edit_form.html
dictionary/templates/lexeme_edit_form_row.html
dictionary/templates/prompter_list.html
dictionary/urls.py
dictionary/views.py
dictionary/wsjp.py
history/lexeme_history.py
@@ -227,4 +227,9 @@ label {
  
 .radio.checked {
     background-position: 0 0;
+}
+
+.ellipsis-icon {
+    display: block;
+    width: 16px;
 }
 \ No newline at end of file
@@ -50,10 +50,10 @@ class LexemeQuery(SlickGridQuery):
         'entry': lambda lexeme: lexeme.entry,
         'abbr_pos': lambda lexeme: lexeme.part_of_speech.pos_name.abbr,
         'pos': lambda lexeme: lexeme.part_of_speech_id,
-        'patterns': lambda lexeme: lexeme.lip_data()['patterns'],
+        'patterns': lambda lexeme: lexeme.inflection_data()['patterns'],
         'genders': lambda lexeme:
             getattr(lexeme.attribute_value(ASPECT), 'value', '') or
-            lexeme.lip_data()['genders'],
+            lexeme.inflection_data()['genders'],
         'vocabs': lambda lexeme: '/'.join(lexeme.vocab_list()),
         'owner': lambda lexeme: lexeme.owner_vocabulary_id,
         'status': lambda lexeme:
@@ -81,7 +81,7 @@ class LexemeQuery(SlickGridQuery):
         'containing_vocabulary': 'vocabularies__id',
         'owner_vocabulary': 'owner_vocabulary_id',
         'lexeme_qualifier': 'qualifiers__id',
-        'lip_qualifier': 'inflection__qualifiers__id',
+        'inflection_qualifier': 'inflection__qualifiers__id',
         'qualifier': 'qualifiers_cache__id',
         'classification_value': 'classificationvalue__id',
         'borrowing_source': 'borrowing_source_id',
@@ -111,7 +111,7 @@ class LexemeQuery(SlickGridQuery):
             'w_id', 'odmieniasie', 'wzory', 'w_id', 'id', 'l_id', ident),
         'pattern_type': (
             'typ', 'odmieniasie', 'wzory', 'w_id', 'id', 'l_id', int_list),
-        'lip_qualifier': (
+        'inflection_qualifier': (
             'qualifier_id', 'odmieniasie', 'kwalifikatory_odmieniasiow',
             'id', 'inflection_id', 'l_id', int_list),
     }
@@ -10,8 +10,8 @@ from common.decorators import ajax, AjaxError, render_ajax
 from common.util import error_messages, bisect_left, format_date
 from dictionary.ajax_lexeme_slickgrid import LexemeQuery
 from dictionary.auto_derivatives import lexeme_derivatives, create_derivative
-from dictionary.forms import LexemeEditForm, LIPEditForm, ClassificationForm, \
-    CrossReferenceForm, ActionFieldForm, ACTION_FIELDS,\
+from dictionary.forms import LexemeEditForm, InflectionEditForm, \
+    ClassificationForm, CrossReferenceForm, ActionFieldForm, ACTION_FIELDS,\
     LexemeOpenAttributeForm, LexemeClosedAttributeForm, \
     LexemeMultipleAttributeForm
 from dictionary.models import Lexeme, Inflection, PartOfSpeech, Vocabulary, \
@@ -142,13 +142,14 @@ def lexeme_edit_form(request, id):
     to_return['classification_forms'] = make_classification_forms(
         l, editable=editable)
  
-    lips = l.inflection_set.all()
-    to_return['lip_forms'] = [
-        (LIPEditForm(
-            part_of_speech=l.part_of_speech, instance=lip,
-            prefix='lip' + str(lip.pk), user=request.user, editable=editable),
-         lip.qualifiers.filter(vocabulary=owner) if ro_owner else [])
-        for lip in lips]
+    inflections = l.inflection_set.all()
+    to_return['inflection_forms'] = [
+        (InflectionEditForm(
+            part_of_speech=l.part_of_speech, instance=inflection,
+            prefix='inf' + str(inflection.pk), user=request.user,
+            editable=editable),
+         inflection.qualifiers.filter(vocabulary=owner) if ro_owner else [])
+        for inflection in inflections]
     to_return['cross_references'] = l.cross_references(request.user)
     if l.homonym_count(request.user) > 0:
         to_return['homonym'] = l.homonym_number
@@ -198,16 +199,16 @@ def classification_forms(request, lexeme_id, vocab_id, pos):
  
  
 @render_ajax(template='lexeme_edit_form_row.html', method='get')
-def new_lip_edit_row(request, lexeme_id, pos_id, num):
+def new_inflection_edit_row(request, lexeme_id, pos_id, num):
     l = Lexeme.all_objects.get(pk=lexeme_id)
     if not l.perm(request.user, 'change'):
         raise AjaxError('access denied')
     if not pos_id:
         raise AjaxError(_(u'Unspecified part of speech.'))
     pos = PartOfSpeech.objects.get(pk=pos_id)
-    lip_form = LIPEditForm(
-        part_of_speech=pos, prefix='lip_add_%s' % num, user=request.user)
-    return {'lip_form': lip_form, 'editable': True}
+    inflection_form = InflectionEditForm(
+        part_of_speech=pos, prefix='inf_add_%s' % num, user=request.user)
+    return {'inflection_form': inflection_form, 'editable': True}
  
  
 @render_ajax(template='cross_reference_row.html', method='get')
@@ -314,38 +315,41 @@ def update_lexeme(request, form_data):
                     'no_other_refs': rev_cr.from_lexeme.refs_to.count() == 1,
                 })
         cr.delete()
-    submitted_lips = []
+    submitted_inflections = []
     submitted_crs = []
     pattern_types = set()
     for pair in form_data:
         name = pair['name']
         prefix = name.split('-')[0]
-        if name.startswith('lip') and prefix not in submitted_lips:
-            submitted_lips.append(prefix)
-            if prefix.startswith('lip_add'):
-                lip = Inflection()
-                lip.lexeme = l
+        if name.startswith('inf') and prefix not in submitted_inflections:
+            submitted_inflections.append(prefix)
+            if prefix.startswith('inf_add'):
+                inflection = Inflection()
+                inflection.lexeme = l
             else:
                 pk = int(prefix[3:])
-                lip = Inflection.objects.get(pk=pk)
+                inflection = Inflection.objects.get(pk=pk)
             form_dict[prefix + '-qualifiers'] = get_list(
                 form_data, prefix + '-qualifiers')
-            lip_form = LIPEditForm(
+            inflection_form = InflectionEditForm(
                 part_of_speech=l.part_of_speech, data=form_dict, prefix=prefix,
-                instance=lip, user=request.user, index=len(submitted_lips))
-            if lip_form.is_valid():
-                lip = lip_form.save()
-                lip.root = l.get_root(lip.pattern, lip.gender)
-                if lip.root is None:
+                instance=inflection, user=request.user,
+                index=len(submitted_inflections))
+            if inflection_form.is_valid():
+                inflection = inflection_form.save()
+                inflection.root = l.get_root(
+                    inflection.pattern, inflection.gender)
+                if inflection.root is None:
                     raise AjaxError(
                         _(u'Basic form ending doesn\'t match the pattern'))
-                for qualifier in lip_form.fields['qualifiers'].queryset:
+                for qualifier in inflection_form.fields['qualifiers'].queryset:
                     qualifier.set_for(
-                        lip, qualifier in lip_form.cleaned_data['qualifiers'])
-                lip.save()
-                pattern_types.add(lip.pattern)
+                        inflection,
+                        qualifier in inflection_form.cleaned_data['qualifiers'])
+                inflection.save()
+                pattern_types.add(inflection.pattern)
             else:
-                raise AjaxError(error_messages(lip_form))
+                raise AjaxError(error_messages(inflection_form))
         if name.startswith('cr_add') and prefix not in submitted_crs:
             submitted_crs.append(prefix)
             cr_form = CrossReferenceForm(data=form_dict, prefix=prefix)
@@ -364,7 +368,7 @@ def update_lexeme(request, form_data):
                             })
             else:
                 raise AjaxError(error_messages(cr_form))
-    if len(submitted_lips) == 0 and l.is_public():
+    if len(submitted_inflections) == 0 and l.is_public():
         raise AjaxError(
             _(u'Enter inflection or set “candidate” or “litter” status.'))
     if l.part_of_speech_id not in ('subst', 'v') and len(pattern_types) > 1:
@@ -462,10 +466,10 @@ def create_derivatives(request, lexeme_id, chosen_derivatives):
 def cr_tuple(cr):
     pos = cr.to_lexeme.part_of_speech.symbol
     if pos in ('ppas', 'appas'):
-        lip = cr.to_lexeme.inflection_set.get()
+        inflection = cr.to_lexeme.inflection_set.get()
         ending9 = Ending.objects.get(
-            pattern=lip.pattern, base_form_label__symbol='9')
-        plnommo = lip.root + ending9.string
+            pattern=inflection.pattern, base_form_label__symbol='9')
+        plnommo = inflection.root + ending9.string
         return cr.type.symbol, cr.to_lexeme.entry, plnommo, pos
     else:
         return cr.type.symbol, cr.to_lexeme.entry, pos
@@ -534,17 +538,18 @@ def update_lexeme_qualifiers(lexeme, user, form_dict, form_data):
             lexeme, unicode(qualifier.pk) in form_dict.get('qualifiers', ()))
     for vocab in editable_vocabs:
         vocab.set_lexeme(lexeme, vocab.pk in form_dict['vocabularies'])
-    submitted_lips = []
+    submitted_inflections = []
     for pair in form_data:
         name = pair['name']
         prefix = name.split('-')[0]
-        if name.startswith('lip') and prefix not in submitted_lips:
-            submitted_lips.append(prefix)
+        if name.startswith('inf') and prefix not in submitted_inflections:
+            submitted_inflections.append(prefix)
             pk = int(prefix[3:])
-            lip = Inflection.objects.get(pk=pk)
-            lip_qualifiers = get_list(form_data, prefix + '-qualifiers')
+            inflection = Inflection.objects.get(pk=pk)
+            inflection_qualifiers = get_list(form_data, prefix + '-qualifiers')
             for qualifier in qualifiers:
-                qualifier.set_for(lip, unicode(qualifier.pk) in lip_qualifiers)
+                qualifier.set_for(
+                    inflection, unicode(qualifier.pk) in inflection_qualifiers)
     return {}
  
  
@@ -582,10 +587,10 @@ def check_pos(request, pos_id, had_gender):
  
 @ajax(method='get')
 def check_pattern(request, pattern_name, gender_id):
-    lips = Inflection.objects.filter(
+    inflections = Inflection.objects.filter(
         gender_id=gender_id, pattern__name=pattern_name)
-    lips = lips.exclude(lexeme__status__in=Lexeme.HIDDEN_STATUSES)
-    if lips.exists():
+    inflections = inflections.exclude(lexeme__status__in=Lexeme.HIDDEN_STATUSES)
+    if inflections.exists():
         return {'answer': 'yes'}
     else:
         return {'answer': 'no'}
@@ -636,11 +641,12 @@ def clone_lexeme(request, lexeme_id):
     new_lexeme.fix_homonym_number()  # nie zadziałał :/
     new_lexeme.save()
     new_lexeme.qualifiers = lexeme.qualifiers.all()
-    for lip in lexeme.inflection_set.all():
-        new_lip = Inflection.objects.create(
-            lexeme=new_lexeme, index=lip.index, pattern=lip.pattern,
-            gender=lip.gender, root=lip.root)
-        new_lip.qualifiers = lip.qualifiers.all()
+    for inflection in lexeme.inflection_set.all():
+        new_inflection = Inflection.objects.create(
+            lexeme=new_lexeme, index=inflection.index,
+            pattern=inflection.pattern, gender=inflection.gender,
+            root=inflection.root)
+        new_inflection.qualifiers = inflection.qualifiers.all()
     for lav in lexeme.lexemeav_set.all():
         LexemeAV.objects.create(
             lexeme=new_lexeme, attribute_value=lav.attribute_value)
@@ -672,32 +678,33 @@ def cr_homonyms(request, entry, cr_type):
     if pos in aspect.parts_of_speech.all():
         middle_labels = (_(u'Aspect'),)
  
-        def middle_fields(lexeme, lip_data):
+        def middle_fields(lexeme, inflection_data):
             aspect_value = lexeme.attribute_value(aspect)
             return aspect_value.value if aspect_value else '',
     elif pos.inflection_type_id == 'subst':
         middle_labels = (_(u'Gender'),)
  
-        def middle_fields(lexeme, lip_data):
-            return lip_data['genders'],
+        def middle_fields(lexeme, inflection_data):
+            return inflection_data['genders'],
     else:
         middle_labels = ()
  
-        def middle_fields(lexeme, lip_data):
+        def middle_fields(lexeme, inflection_data):
             return ()
     labels = (
         (_(u'Hom. №'),) + middle_labels +
         (_(u'Pattern'), _(u'Dictionaries'), _(u'Status')))
  
-    def make_row(lexeme, lip_data):
+    def make_row(lexeme, inflection_data):
         status = force_unicode(dict(Lexeme.STATUS_CHOICES)[lexeme.status])
         vocabs = '/'.join(lexeme.vocab_list())
         return (
-            (lexeme.homonym_number,) + middle_fields(lexeme, lip_data) +
-            (lip_data['patterns'], vocabs, status))
+            (lexeme.homonym_number,) + middle_fields(lexeme, inflection_data) +
+            (inflection_data['patterns'], vocabs, status))
  
     lexemes_data = [
-        make_row(l, l.lip_data()) for l in lexemes.order_by('homonym_number')
+        make_row(l, l.inflection_data())
+        for l in lexemes.order_by('homonym_number')
     ]
     return {'labels': labels, 'lexemes': lexemes_data}
  
@@ -8,37 +8,39 @@ from patterns.pattern_blacklist import blacklist
  
 commonness = Classification.objects.get(name=u'pospolitość')
  
-LIP_ROWS = 10
+INFLECTION_ROWS = 10
  
  
 def make_list(user, entry, pos, gender, cvs, bl_check):
-    lips = Inflection.objects.distinct()
-    lips = Inflection.filter_visible(lips, user)
-    lips = lips.filter(
+    inflections = Inflection.objects.distinct()
+    inflections = Inflection.filter_visible(inflections, user)
+    inflections = inflections.filter(
         lexeme__part_of_speech__symbol=pos).exclude(
         lexeme__status__in=Lexeme.HIDDEN_STATUSES)
     if gender:
-        lips = lips.filter(gender=gender)
+        inflections = inflections.filter(gender=gender)
     if cvs:
-        lips = lips.filter(lexeme__classificationvalue__in=cvs)
-    lips = lips.select_related('pattern', 'gender', 'lexeme')
-    lips = lips.order_by('lexeme__entry')
+        inflections = inflections.filter(lexeme__classificationvalue__in=cvs)
+    inflections = inflections.select_related('pattern', 'gender', 'lexeme')
+    inflections = inflections.order_by('lexeme__entry')
     feature_sets = set()
     bad_inflections = set()
-    chosen_lips = []
+    chosen_inflections = []
     for suf_len in xrange(len(entry), 0, -1):
         suf = suffix(entry, suf_len)
-        suf_lips = lips.filter(lexeme__entry__endswith=suf)
+        suf_inflections = inflections.filter(lexeme__entry__endswith=suf)
         if suf_len < len(entry):
             suf1 = suffix(entry, suf_len + 1)
-            suf_lips = suf_lips.exclude(lexeme__entry__endswith=suf1)
+            suf_inflections = suf_inflections.exclude(
+                lexeme__entry__endswith=suf1)
         for p0, gender0 in bad_inflections:
-            suf_lips.exclude(pattern=p0, gender=gender0)
+            suf_inflections.exclude(pattern=p0, gender=gender0)
         for p0, gender0 in feature_sets:
-            suf_lips = suf_lips.exclude(pattern=p0, gender=gender0)
-        for lip in suf_lips:
-            p = lip.pattern
-            l_gender = lip.gender
+            suf_inflections = suf_inflections.exclude(
+                pattern=p0, gender=gender0)
+        for inflection in suf_inflections:
+            p = inflection.pattern
+            l_gender = inflection.gender
             if p.name in blacklist and bl_check:
                 continue
             if (p, l_gender) in bad_inflections:
@@ -46,21 +48,22 @@ def make_list(user, entry, pos, gender, cvs, bl_check):
             if (p, l_gender) in feature_sets:
                 continue
             if p.get_root(entry, l_gender) is not None:
-                l_cvs = lip.lexeme.classification_values(commonness)
-                l_root = lip.lexeme.get_root(p, l_gender)
-                l_end = lip.lexeme.entry[len(l_root):]
+                l_cvs = inflection.lexeme.classification_values(commonness)
+                l_root = inflection.lexeme.get_root(p, l_gender)
+                l_end = inflection.lexeme.entry[len(l_root):]
                 l_entry = u'%s·%s' % (l_root, l_end)
                 if len(l_end) < len(suf):
                     suf = suffix(l_entry, suf_len + 1)
-                chosen_lips.append((lip, l_cvs, cut_end(l_entry, suf), suf))
+                chosen_inflections.append(
+                        (inflection, l_cvs, cut_end(l_entry, suf), suf))
                 feature_sets.add((p, l_gender))
-                if len(chosen_lips) == LIP_ROWS:
+                if len(chosen_inflections) == INFLECTION_ROWS:
                     break
             else:
                 bad_inflections.add((p, l_gender))
-        if len(chosen_lips) == LIP_ROWS:
+        if len(chosen_inflections) == INFLECTION_ROWS:
             break
-    return chosen_lips
+    return chosen_inflections
  
  
 @ajax(method='get', template='prompter_list.html',
@@ -72,6 +75,6 @@ def prompter_list(request, entry, pos_id, commonness_ids,
         cvs = list(ClassificationValue.objects.filter(pk__in=commonness_ids))
     else:
         cvs = None
-    lips = make_list(request.user, entry, pos_id, gender, cvs, bl_check)
+    inflections = make_list(request.user, entry, pos_id, gender, cvs, bl_check)
     # zakładamy, że symbol == pk
-    return {'lips': lips}
+    return {'inflections': inflections}
@@ -28,9 +28,9 @@ NO_ZLOZ = LexemeAttributeValue.objects.get(
     value=u'nieobecna', attribute__name=u'forma złoż.')
  
  
-def ppas_data(lips, pos='ppas'):
-    for lip in lips:
-        pattern = lip.pattern
+def ppas_data(inflections, pos='ppas'):
+    for inflection in inflections:
+        pattern = inflection.pattern
         endings10 = Ending.objects.filter(
             pattern=pattern, base_form_label__symbol='10')
         endings12 = Ending.objects.filter(
@@ -40,37 +40,37 @@ def ppas_data(lips, pos=&#39;ppas&#39;):
                 yield {
                     'pos': pos,
                     'cr_type': 'verppas',
-                    'entry': lip.root + ending.string + 'y',
-                    'pl': lip.root + ending12.string,
-                    'index': lip.index,
+                    'entry': inflection.root + ending.string + 'y',
+                    'pl': inflection.root + ending12.string,
+                    'index': inflection.index,
                 }
  
  
-def pact_data(lips):
-    for lip in lips:
-        pattern = lip.pattern
+def pact_data(inflections):
+    for inflection in inflections:
+        pattern = inflection.pattern
         endings3 = Ending.objects.filter(
             pattern=pattern, base_form_label__symbol='3')
         for ending in endings3:
             yield {
                 'pos': 'pact',
                 'cr_type': 'verpact',
-                'entry': lip.root + ending.string + 'cy',
-                'index': lip.index,
+                'entry': inflection.root + ending.string + 'cy',
+                'index': inflection.index,
             }
  
  
-def ger_data(lips):
-    for lip in lips:
-        pattern = lip.pattern
+def ger_data(inflections):
+    for inflection in inflections:
+        pattern = inflection.pattern
         endings11 = Ending.objects.filter(
             pattern=pattern, base_form_label__symbol='11')
         for ending in endings11:
             yield {
                 'pos': 'ger',
                 'cr_type': 'verger',
-                'entry': lip.root + ending.string + 'ie',
-                'index': lip.index,
+                'entry': inflection.root + ending.string + 'ie',
+                'index': inflection.index,
             }
  
  
@@ -101,8 +101,8 @@ def make_negation(s):
  
  
 def lexeme_derivatives(lexeme):
-    lips = list(lexeme.inflection_set.all())
-    if not lips:
+    inflections = list(lexeme.inflection_set.all())
+    if not inflections:
         return
     if lexeme.part_of_speech.symbol == 'v':
         proper = lexeme.lexemeattributevalue_set.filter(
@@ -116,12 +116,12 @@ def lexeme_derivatives(lexeme):
                 attribute__name=u'aspekt').exclude(value='dk')
             if trans or q_trans:
                 pos = 'ppas' if trans else 'appas'
-                for data in ppas_data(lips, pos):
+                for data in ppas_data(inflections, pos):
                     yield data
             if imperf:
-                for data in pact_data(lips):
+                for data in pact_data(inflections):
                     yield data
-            for data in ger_data(lips):
+            for data in ger_data(inflections):
                 yield data
     elif lexeme.part_of_speech.symbol == 'adj':
         # adjcom, adv, advcom, osc, nieadj
@@ -162,50 +162,51 @@ def create_derivative(lexeme, part_of_speech, cr_type, entry, index, pl=None):
     der.fix_homonym_number()
     lexeme.owner_vocabulary.add_lexeme(der)
     if not negation:
-        lip = Inflection(lexeme=der, index=1)
+        inflection = Inflection(lexeme=der, index=1)
         if part_of_speech in ('ppas', 'appas'):
             # -ty/-ci
             if entry.endswith('ty'):
-                lip.pattern = Pppas_ty
+                inflection.pattern = Pppas_ty
             # -iony/-eni
             elif entry.endswith('iony') and not pl.endswith('ieni'):
-                lip.pattern = Pppas_iony_ieni
+                inflection.pattern = Pppas_iony_ieni
             # -ony/-eni
             elif entry.endswith('eni'):
-                lip.pattern = Pppas_ony_eni
+                inflection.pattern = Pppas_ony_eni
             # -ny/-ni
             else:
-                lip.pattern = Pppas_ny_ni
+                inflection.pattern = Pppas_ny_ni
         elif part_of_speech == 'pact':
-            lip.pattern = Ppact
+            inflection.pattern = Ppact
         elif part_of_speech == 'ger':
-            lip.gender = n2
+            inflection.gender = n2
             if entry.endswith('cie'):
-                lip.pattern = Pger_cie
+                inflection.pattern = Pger_cie
             else:  # -nie
-                lip.pattern = Pger_nie
+                inflection.pattern = Pger_nie
         elif part_of_speech == 'osc':
-            lip.pattern = Posc
-            lip.gender = f
+            inflection.pattern = Posc
+            inflection.gender = f
         elif part_of_speech == 'adjcom':
-            lip.pattern = Pcom
+            inflection.pattern = Pcom
         elif part_of_speech in ('adv', 'advcom'):
-            lip.pattern = Pndm
-        lip.root = lip.get_root()
-        lip.save()
-        orig_lip = Inflection.objects.get(lexeme=lexeme, index=index)
+            inflection.pattern = Pndm
+        inflection.root = inflection.get_root()
+        inflection.save()
+        orig_inflection = Inflection.objects.get(lexeme=lexeme, index=index)
         # może kopiować kwalifikatory odmieniasia do leksemu?
-        for q in orig_lip.qualifiers.all():
-            lip.qualifiers.add(q)  # der zamiast lip?
+        for q in orig_inflection.qualifiers.all():
+            inflection.qualifiers.add(q)  # der zamiast inflection?
     else:
-        for orig_lip in lexeme.inflection_set.all():
-            lip = Inflection(
-                lexeme=der, index=orig_lip.index, pattern=orig_lip.pattern,
-                gender=orig_lip.gender)
-            lip.root = lip.get_root()
-            lip.save()
-            for q in orig_lip.qualifiers.all():
-                lip.qualifiers.add(q)
+        for orig_inflection in lexeme.inflection_set.all():
+            inflection = Inflection(
+                lexeme=der, index=orig_inflection.index,
+                pattern=orig_inflection.pattern,
+                gender=orig_inflection.gender)
+            inflection.root = inflection.get_root()
+            inflection.save()
+            for q in orig_inflection.qualifiers.all():
+                inflection.qualifiers.add(q)
     for attr, attr_val in lexeme.attributes_values():
         if attr not in (ATTR_POPRZ, ATTR_ZLOZ) and attr_val \
                 and attr.parts_of_speech.filter(symbol=part_of_speech):
@@ -200,18 +200,18 @@ class LexemeMultipleAttributeForm(LexemeAttributeForm):
         self.fields['value'].help_text = ''
  
  
-class LIPEditForm(ModelForm):
+class InflectionEditForm(ModelForm):
     pattern_name = CharField(widget=TextInput(
         attrs={'class': 'pattern', 'size': '10'}), label=_(u'Pattern'))
     qualifiers = QualifiersField(
         required=False, label=_(u'Qual.'),
-        widget=SelectMultiple(attrs={'class': 'lip-qualifiers'}))
+        widget=SelectMultiple(attrs={'class': 'inflection-qualifiers'}))
     inflection_type = CharField(
-        widget=HiddenInput(attrs={'class': 'lip-it'}), label=u'')
+        widget=HiddenInput(attrs={'class': 'inflection-it'}), label=u'')
  
     def __init__(self, part_of_speech, user, editable=True, index=None,
                  **kwargs):
-        super(LIPEditForm, self).__init__(**kwargs)
+        super(InflectionEditForm, self).__init__(**kwargs)
         if part_of_speech.inflection_type_id != 'subst':
             self.fields['gender'].widget = HiddenInput()
             self.fields['gender'].label = ''
@@ -242,13 +242,13 @@ class LIPEditForm(ModelForm):
         return cleaned_data
  
     def save(self, *args, **kwargs):
-        lip = self.instance
-        lip.pattern = self.cleaned_data['pattern']
+        inflection = self.instance
+        inflection.pattern = self.cleaned_data['pattern']
         if self.index:
-            lip.index = self.index
-        super(LIPEditForm, self).save(*args, **kwargs)
-        lip.save()
-        return lip
+            inflection.index = self.index
+        super(InflectionEditForm, self).save(*args, **kwargs)
+        inflection.save()
+        return inflection
  
     class Meta:
         model = Inflection
@@ -256,7 +256,7 @@ class LIPEditForm(ModelForm):
         widgets = {
             'gender': Select(attrs={'class': 'gender'}),
             'pronunciation': TextInput(
-                attrs={'class': 'lip-pronunciation-field'}),
+                attrs={'class': 'inflection-pronunciation-field'}),
         }
  
  
@@ -60,32 +60,32 @@ def import_subst(elements, comment):
         raise
     assert pos == 'subst'
     genders = [Gender.objects.get(symbol=g) for g in gender.split('/')]
-    lip_data = [p.rsplit(' ', 1) for p in pattern_data.split('/')]
-    if len(genders) > 1 and len(lip_data) > 1:
+    inflection_data = [p.rsplit(' ', 1) for p in pattern_data.split('/')]
+    if len(genders) > 1 and len(inflection_data) > 1:
         print >>sys.stderr, 'mnogie wzory i rodzaje', elements
         return
     if len(genders) == 1:
-        lip_data = [(ld, genders[0]) for ld in lip_data]
+        inflection_data = [(ld, genders[0]) for ld in inflection_data]
     else:
-        lip_data = [(lip_data[0], g) for g in genders]
+        inflection_data = [(inflection_data[0], g) for g in genders]
     l = new_lexeme(entry, 'subst', comment)
     comm_value = ClassificationValue.objects.get(
         classification__name=u'pospolitość', label=commonness)
     LexemeCV.objects.create(lexeme=l, classification_value=comm_value)
-    for i, (ld, gender) in enumerate(lip_data, 1):
-        lip = Inflection(lexeme=l, index=i, gender=gender)
+    for i, (ld, gender) in enumerate(inflection_data, 1):
+        inflection = Inflection(lexeme=l, index=i, gender=gender)
         if len(ld) == 1:
             pattern = ld[0]
             qualifier = None
         else:
             qualifier, pattern = ld
-        lip.pattern = Pattern.objects.get(name=pattern)
-        lip.root = lip.get_root()
-        if lip.get_root() is None:
+        inflection.pattern = Pattern.objects.get(name=pattern)
+        inflection.root = inflection.get_root()
+        if inflection.get_root() is None:
             raise ValueError(u"%s: can't find root" % repr(entry))
-        lip.save()
+        inflection.save()
         if qualifier:
-            lip.qualifiers.add(Qualifier.objects.get(label=qualifier))
+            inflection.qualifiers.add(Qualifier.objects.get(label=qualifier))
  
  
 NDM = Pattern.objects.get(name='ndm')  # hardcoded pattern
@@ -100,9 +100,9 @@ def import_adv(elements, comment):
         raise
     assert pos == 'adv' and pattern_name == 'ndm'
     l = new_lexeme(entry, 'adv', comment)
-    lip = Inflection(lexeme=l, index=1, pattern=NDM)
-    lip.root = lip.get_root()
-    lip.save()
+    inflection = Inflection(lexeme=l, index=1, pattern=NDM)
+    inflection.root = inflection.get_root()
+    inflection.save()
     adjs = Lexeme.objects.filter(entry=adj_entry)
     if len(adjs) == 1:
         adj = adjs.get()
@@ -143,6 +143,6 @@ def import_adj(elements, comment):
     else:
         NO_POPRZ.add_lexeme(l)
     pattern = Pattern.objects.get(name=pattern_name)
-    lip = Inflection(lexeme=l, index=1, pattern=pattern)
-    lip.root = lip.get_root()
-    lip.save()
 \ No newline at end of file
+    inflection = Inflection(lexeme=l, index=1, pattern=pattern)
+    inflection.root = inflection.get_root()
+    inflection.save()
 \ No newline at end of file
@@ -342,36 +342,36 @@ class Lexeme(Model):
     all_objects = Manager()
  
     def inflection_tables(self, variant, qualifiers=None):
-        lips = self.inflection_set.order_by(
+        inflections = self.inflection_set.order_by(
             'index').select_related('gender', 'pattern')
         genders = OrderedDict()
-        for lip in lips:
-            g = lip.gender
+        for inflection in inflections:
+            g = inflection.gender
             if g not in genders:
                 genders[g] = {'patterns': [], 'pronunciations': []}
-            genders[g]['patterns'].append(lip.pattern)
-            if lip.pronunciation:
-                genders[g]['pronunciations'].append(lip.pronunciation)
+            genders[g]['patterns'].append(inflection.pattern)
+            if inflection.pronunciation:
+                genders[g]['pronunciations'].append(inflection.pronunciation)
         return [
             (gender, val['patterns'], val['pronunciations']) +
             self.inflection_table(variant, gender, qualifiers=qualifiers)
             for gender, val in genders.iteritems()]
  
     def inflection_table(self, variant, gender, qualifiers=None):
-        lips = self.inflection_set.prefetch_related(
+        inflections = self.inflection_set.prefetch_related(
             'qualifiers').select_related('pattern__type', 'gender')
         if gender:
-            lips = lips.filter(gender=gender)
+            inflections = inflections.filter(gender=gender)
         span = unicode(variant) == u'0'
-        gender_qualifiers = lips[0].qualifiers.all() & qualifiers
+        gender_qualifiers = inflections[0].qualifiers.all() & qualifiers
         attr = LexemeAttribute.objects.get(name=u'nacechowana forma')
         depr = self.attribute_value(attr)
         tables = [
-            lip.inflection_table(
+            inflection.table(
                 variant, qualifiers=qualifiers, span=span,
                 depr=depr, cell_qualifier=True,
                 edit_view=(i == 0))  # brzydko, ale cóż
-            for i, lip in enumerate(lips)]
+            for i, inflection in enumerate(inflections)]
         table1 = tables[0]
         for table2 in tables[1:]:
             while len(table2) > len(table1):
@@ -395,10 +395,11 @@ class Lexeme(Model):
  
     def all_forms(self, label_filter=None, variant='1'):
         forms = set()
-        for lip in self.inflection_set.all():
+        for inflection in self.inflection_set.all():
             forms |= set(
                 form for (indexes, form, qualifiers)
-                in lip.all_forms(label_filter=label_filter, variant=variant))
+                in inflection.all_forms(
+                    label_filter=label_filter, variant=variant))
         return forms
  
     def refresh_forms(self):
@@ -408,10 +409,10 @@ class Lexeme(Model):
  
     def all_qualifiers(self, variant='1'):
         qualifiers = set(self.qualifiers.all())
-        for lip in self.inflection_set.all():
+        for inflection in self.inflection_set.all():
             qualifiers |= set(
                 qualifier for (indexes, form, qualifiers)
-                in lip.all_forms(variant=variant)
+                in inflection.all_forms(variant=variant)
                 for qualifier in qualifiers)
         return qualifiers
  
@@ -444,24 +445,24 @@ class Lexeme(Model):
             classification=classification)
  
     def pattern_list(self):
-        lips = self.inflection_set.all()
+        inflections = self.inflection_set.all()
         patterns = []
-        for lip in lips:
-            if patterns == [] or lip.pattern != patterns[-1]:
-                patterns.append(lip.pattern)
+        for inflection in inflections:
+            if patterns == [] or inflection.pattern != patterns[-1]:
+                patterns.append(inflection.pattern)
         return patterns
  
-    def lip_data(self, lips=None):
-        if lips is None:
-            lips = self.inflection_set.all()
+    def inflection_data(self, inflections=None):
+        if inflections is None:
+            inflections = self.inflection_set.all()
         patterns = []
         genders = []
-        for lip in lips:
-            if patterns == [] or lip.pattern.name != patterns[-1]:
-                patterns.append(lip.pattern.name)
-            if (lip.gender and
-                    (genders == [] or lip.gender.symbol != genders[-1])):
-                genders.append(lip.gender.symbol)
+        for inflection in inflections:
+            if patterns == [] or inflection.pattern.name != patterns[-1]:
+                patterns.append(inflection.pattern.name)
+            if (inflection.gender and
+                    (genders == [] or inflection.gender.symbol != genders[-1])):
+                genders.append(inflection.gender.symbol)
         patterns = '/'.join(patterns)
         genders = '/'.join(genders)
         return {'patterns': patterns, 'genders': genders}
@@ -538,8 +539,8 @@ class Lexeme(Model):
     def attributes(self, part_of_speech=None, genders=None):
         pos = part_of_speech or self.part_of_speech
         if genders is None and pos.inflection_type_id == 'subst':
-            lips = self.inflection_set.all()
-            genders = [lip.gender for lip in lips]
+            inflections = self.inflection_set.all()
+            genders = [inflection.gender for inflection in inflections]
         elif genders is None:
             genders = []
         attrs = LexemeAttribute.objects.all()
@@ -739,22 +740,22 @@ class Inflection(Model):
     def base_endings(self, label_filter=None):
         return self.pattern.base_endings(label_filter)
  
-    def inflection_table(self, variant, edit_view=False, attr_vals=None,
-                         pos=None, depr=None, **kwargs):
+    def table(self, variant, edit_view=False, attr_vals=None,
+              pos=None, depr=None, **kwargs):
         part_of_speech = pos or self.lexeme.part_of_speech
         tt = self.table_template(
             variant, attr_vals=attr_vals, pos=part_of_speech)
         if tt is None:
             return []
-        lip_qualifiers = self.qualifiers.all() if not edit_view else []
+        inflection_qualifiers = self.qualifiers.all() if not edit_view else []
         if attr_vals is None:
             attr_vals = self.lexeme.lexemeattributevalue_set.all()
         if depr and (not self.gender or self.gender.symbol != 'm1'):
             depr = None
         return tt.render_with_pattern(
             self.pattern, self.gender, attr_vals,
-            root=self.root, edit_view=edit_view, lip_index=self.index,
-            lip_qualifiers=lip_qualifiers, depr=depr, **kwargs)
+            root=self.root, edit_view=edit_view, inflection_index=self.index,
+            inflection_qualifiers=inflection_qualifiers, depr=depr, **kwargs)
  
     def all_forms(self, label_filter=None, variant='1', **kwargs):
         forms = []
@@ -762,8 +763,8 @@ class Inflection(Model):
         for cell in self.cells(variant=variant):
             forms += cell.forms(
                 base_endings=base_endings, root=self.root,
-                lip_qualifiers=self.qualifiers.all(), lip_index=self.index,
-                **kwargs)
+                inflection_qualifiers=self.qualifiers.all(),
+                inflection_index=self.index, **kwargs)
         return forms
  
     def editable_vocabularies(self, user):
@@ -781,11 +782,12 @@ class Inflection(Model):
         )
  
     @staticmethod
-    def filter_visible(lips, user):
+    def filter_visible(inflections, user):
         vocabs = Vocabulary.visible_vocabularies(user)
         if not user.is_authenticated():
-            lips = lips.exclude(lexeme__status__in=Lexeme.HIDDEN_STATUSES)
-        return lips.filter(lexeme__vocabularies__in=vocabs).distinct()
+            inflections = inflections.exclude(
+                lexeme__status__in=Lexeme.HIDDEN_STATUSES)
+        return inflections.filter(lexeme__vocabularies__in=vocabs).distinct()
  
     class Meta:
         db_table = 'odmieniasie'
@@ -32,7 +32,7 @@ span.pronunciation {
     font-size: small;
 }
  
-span.lip-pronunciation {
+span.inflection-pronunciation {
     font-style: italic;
 }
  
@@ -4,7 +4,7 @@
     padding: 0;
 }
  
-.lip-pronunciation-field {
+.inflection-pronunciation-field {
     width: 90px;
 }
  
@@ -130,11 +130,6 @@ table#prompter-list .cv ul li {
     height: 30px;
 }
  
-.ellipsis-icon {
-    display: block;
-    width: 16px;
-}
-
 tr.search-by-form-row:nth-child(odd) {
     background: #bbb;
 }
@@ -73,7 +73,7 @@ $.extend(edit, {
  
     init_form_widgets: function() {
         "use strict";
-        $(document).on('click', '.lip-row span.remove', function () {
+        $(document).on('click', '.inflection-row span.remove', function () {
             var li = $(this).closest('li');
             var name = $('input', li)[0].name;
             var gender = li.find('.gender option:selected').text();
@@ -91,7 +91,7 @@ $.extend(edit, {
                     }
                 }
             }
-            if (name.substring(0, 7) !== 'lip_add')
+            if (name.substring(0, 7) !== 'inf_add')
                 deleted.push(name.split('-')[0]);
             li.remove();
             edit.show_changed();
@@ -105,7 +105,8 @@ $.extend(edit, {
             common.init_selection(new_row.find('.gender'));
             var pattern_list = $('#pattern-list');
             pattern_list.append(new_row);
-            edit.qualifier_select(pattern_list.find('.lip-qualifiers').last());
+            edit.qualifier_select(
+                pattern_list.find('.inflection-qualifiers').last());
             edit.show_changed();
         });
  
@@ -132,9 +133,9 @@ $.extend(edit, {
         });
  
         var update_preview = function () {
-            var lip_row = $(this).closest('.lip-row');
-            if (lip_row.hasClass('lip-row-active')) {
-                set_active_lip_row.call(lip_row);
+            var inflection_row = $(this).closest('.inflection-row');
+            if (inflection_row.hasClass('inflection-row-active')) {
+                set_active_inflection_row.call(inflection_row);
             }
         };
         $(document).on(
@@ -144,7 +145,7 @@ $.extend(edit, {
         $(document).on(
             'change', '#' + edit.form_id + ' select', update_preview);
  
-        $(document).on('click', '.lip-row', set_active_lip_row);
+        $(document).on('click', '.inflection-row', set_active_inflection_row);
  
         $(document).on('click', '.lexeme-edit-delete', delete_lexeme);
  
@@ -319,7 +320,7 @@ $.extend(edit, {
             }
         });
         //$('#pattern-list').disableSelection();
-        $('.lip-row', '#pattern-list').first().click();
+        $('.inflection-row', '#pattern-list').first().click();
         $('#id_vocabularies').multiSelect({
             noneSelectedText: gettext("Choose dictionaries"),
             selectedText: gettext("# dictionaries"),
@@ -336,7 +337,7 @@ $.extend(edit, {
                 toggle_specialist(show);
             }
         });
-        edit.qualifier_select($('select.lip-qualifiers'));
+        edit.qualifier_select($('select.inflection-qualifiers'));
         init_classification_forms();
         init_extra_attr_widgets();
         $('button.prompter').button();
@@ -682,7 +683,7 @@ function before_save() {
     "use strict";
     // sprawdzić wzór z rodzajem
     var ok = true;
-    $('.lip-row').each(function () {
+    $('.inflection-row').each(function () {
         var gender = $(this).find('.gender').val();
         var pattern = $(this).find('.pattern').val();
         if (gender) {
@@ -705,7 +706,7 @@ function get_new_row_html(id) {
     "use strict";
     var new_row_html = $.ajaxJSON({
         method: 'get',
-        url: $dj.ajax_new_lip_row,
+        url: $dj.ajax_new_inflection_row,
         data: {lexeme_id: id, pos_id: get_pos(), num: new_row_counter},
         async: false // w zasadzie się tak nie powinno robić
     }).html;
@@ -713,10 +714,11 @@ function get_new_row_html(id) {
     return new_row_html;
 }
  
-var set_active_lip_row = function () {
+var set_active_inflection_row = function () {
     "use strict";
-    $('.lip-row-active').removeClass('lip-row-active ui-state-active');
-    $(this).addClass('lip-row-active ui-state-active');
+    $('.inflection-row-active').removeClass(
+        'inflection-row-active ui-state-active');
+    $(this).addClass('inflection-row-active ui-state-active');
     // tabelka
     var data = {
         lexeme_id: slickgrid.get_id(),
@@ -725,7 +727,7 @@ var set_active_lip_row = function () {
         pattern: $('input.pattern', this).value(),
         gender: $('.gender', this).value(),
         attr_data: get_attr_data(),
-        lip_id: $('input.pattern', this)[0].name.split('-')[0]
+        inflection_id: $('input.pattern', this)[0].name.split('-')[0]
     };
     $.ajaxJSON({
         method: 'get',
@@ -797,9 +799,9 @@ function reload_prompter(arg) {
     // załadować dane do promptera
     var elem;
     if (arg.button)
-        elem = $(arg.button).closest('.lip-row');
+        elem = $(arg.button).closest('.inflection-row');
     else
-        elem = $('.lip-row-active');
+        elem = $('.inflection-row-active');
     var gender = elem.find('.gender').val();
     var id = slickgrid.get_id();
     var cvs = $('#id_cl' + $dj.commonness + '-values').val();
@@ -844,7 +846,7 @@ var set_active_prompter_row = function () {
         pattern: $('.pattern', this).text(),
         gender: $('.gender-id', this).text(),
         attr_data: get_attr_data(),
-        lip_id: 'lip_add'
+        inflection_id: 'inf_add'
     };
     $.ajaxJSON({
         method: 'get',
@@ -864,7 +866,7 @@ function input_prompter_pattern() {
     if (active.length > 0) {
         $('#prompter-dialog').dialog('close');
         pattern = active.find('.pattern').text();
-        $('.lip-row-active').find('input.pattern').val(pattern);
+        $('.inflection-row-active').find('input.pattern').val(pattern);
         edit.show_changed();
     }
 }
@@ -918,10 +920,12 @@ var check_pos = function () {
     var pos = get_pos();
     if (!pos)
         return;
-    var bad_lips = false, good_genders = [], confirmed, had_gender;
-    var lip_row_elems = $('.lip-row'), cr_row_elems = $('.cr-row');
-    if (lip_row_elems.length > 0) {
-        had_gender = $(lip_row_elems[0]).find('select.gender').length > 0;
+    var bad_inflections = false, good_genders = [], confirmed, had_gender;
+    var inflection_row_elems = $('.inflection-row'),
+        cr_row_elems = $('.cr-row');
+    if (inflection_row_elems.length > 0) {
+        had_gender = $(inflection_row_elems[0])
+            .find('select.gender').length > 0;
         var pattern = $(this).find('input.pattern').val();
         var answer = $.ajaxJSON({
             method: 'get',
@@ -930,20 +934,20 @@ var check_pos = function () {
             async: false
         }).answer;
         if (answer !== 'yes')
-            bad_lips = true;
+            bad_inflections = true;
     }
-    if (!bad_lips && had_gender) {
-        good_genders = lip_row_elems.map(function(i, elem) {
+    if (!bad_inflections && had_gender) {
+        good_genders = inflection_row_elems.map(function(i, elem) {
             return $(elem).find('.gender').val();
         }).toArray();
     }
     var stale_attrs = check_attrs(good_genders);
     var stale_classifications = check_classifications();
-    if (bad_lips || cr_row_elems.length > 0 ||
+    if (bad_inflections || cr_row_elems.length > 0 ||
         stale_attrs.length > 0 || stale_classifications.length > 0) {
-        var lips_text = '', cr_text = '';
-        if (bad_lips > 0) {
-            lips_text = gettext("all inflections") + '\n';
+        var inflections_text = '', cr_text = '';
+        if (bad_inflections > 0) {
+            inflections_text = gettext("all inflections") + '\n';
         }
         if (cr_row_elems.length > 0) {
             cr_text += gettext("all cross-references") + '\n';
@@ -959,28 +963,29 @@ var check_pos = function () {
                 join_classifications(stale_classifications) + '\n';
         }
         confirmed = window.confirm(
-            gettext("Those will be removed:") + '\n' + lips_text + cr_text +
-            attr_text + clas_text + gettext("Do you want to continue?"));
+            gettext("Those will be removed:") +
+                '\n' + inflections_text + cr_text +
+                attr_text + clas_text + gettext("Do you want to continue?"));
         if (!confirmed) {
             common.revert_selection($(this));
         }
     }
-    if (confirmed || !(bad_lips || cr_row_elems.length > 0 ||
+    if (confirmed || !(bad_inflections || cr_row_elems.length > 0 ||
         stale_attrs.length > 0 || stale_classifications.length > 0)) {
         common.confirm_selection($(this));
         var reload_preview = false;
-        if (bad_lips) {
-            lip_row_elems.each(function () {
+        if (bad_inflections) {
+            inflection_row_elems.each(function () {
                 var li = $(this);
                 // copypasta...
                 var name = li.find('input')[0].name;
-                if (name.substring(0, 7) !== 'lip_add')
+                if (name.substring(0, 7) !== 'inf_add')
                     deleted.push(name.split('-')[0]);
                 li.remove();
                 reload_preview = true;
             });
         }
-        lip_row_elems.find('.lip-it').val($dj.inflection_types[pos]);
+        inflection_row_elems.find('.inflection-it').val($dj.inflection_types[pos]);
         if (reload_preview)
             $('#table-preview').html('');
         cr_row_elems.each(function () {
@@ -191,7 +191,7 @@ $.extend(slickgrid, {
             ops: eqne,
             optgroups: $dj.lexeme_qualifier_options
         },
-        lip_qualifier: {
+        inflection_qualifier: {
             name: gettext("Inflection qual."),
             gender: 'm',
             ops: eqne,
@@ -37,7 +37,7 @@
         </p>
         <p>
             {% if lexeme.part_of_speech.inflection_type_id == 'subst' %}
-                {{ lexeme.lip_data.genders }}
+                {{ lexeme.inflection_data.genders }}
             {% endif %}
             {{ lexeme|attribute:"aspekt" }}
             {% if tables|length == 1 %}
@@ -84,7 +84,7 @@
         {% endif %}
     </p>
     <ul id="pattern-list" {{ editable|yesno:'class="editable",'|safe }}>
-        {% for lip_form, ro_qualifiers in lip_forms %}
+        {% for inflection_form, ro_qualifiers in inflection_forms %}
             {% include 'lexeme_edit_form_row.html' %}
         {% endfor %}
     </ul>
@@ -155,7 +155,7 @@
                         {% endif %}
                     </span>
                     <span class="gender">
-                        {{ cr.to_lexeme.lip_data.genders }}
+                        {{ cr.to_lexeme.inflection_data.genders }}
                         {{ cr.to_lexeme|attribute:"aspekt" }}
                     </span>
                 </li>
-<li class="lip-row ui-state-default ui-corner-all">
+<li class="inflection-row ui-state-default ui-corner-all">
     {% if editable %}
         <span class="remove ui-icon ui-icon-closethick"></span>
         <span class="arrows ui-icon ui-icon-arrowthick-2-n-s"></span>
     {% endif %}
-    {% for field in lip_form %}
+    {% for field in inflection_form %}
         {% if field.name != 'qualifiers' and field.name != 'pronunciation' %}
-            <span class="lip-field">
+            <span class="inflection-field">
                 {{ field.label_tag }} {{ field.as_widget }}
             </span>
         {% endif %}
     {% endfor %}
     {% if editable %}
         <button type="button" class="prompter"
-                id="{{ lip_form.prefix }}-prompter">...</button>
+                id="{{ inflection_form.prefix }}-prompter">...</button>
     {% endif %}
     <p>
         {% if ro_qualifiers %}
             {{ owner.id }}: {{ ro_qualifiers|join:", " }};
         {% endif %}
-        {{ lip_form.qualifiers.label_tag }} {{ lip_form.qualifiers.as_widget }}
-        {{ lip_form.pronunciation.label_tag }} {{ lip_form.pronunciation.as_widget }}
+        {{ inflection_form.qualifiers.label_tag }}
+        {{ inflection_form.qualifiers.as_widget }}
+        {{ inflection_form.pronunciation.label_tag }}
+        {{ inflection_form.pronunciation.as_widget }}
     </p>
 </li>
-{% for lip, cvs, prefix, suffix in lips %}
+{% for inflection, cvs, prefix, suffix in inflections %}
     <tr class="prompter-row">
         <td class="entry">{{ prefix }}<span class="suffix">{{ suffix }}</span>
         </td>
-        {% if lip.gender %}
-            <td class="gender">{{ lip.gender.symbol }}</td>
-            <td class="gender-id">{{ lip.gender_id }}</td>
+        {% if inflection.gender %}
+            <td class="gender">{{ inflection.gender.symbol }}</td>
+            <td class="gender-id">{{ inflection.gender_id }}</td>
         {% endif %}
         <td class="cv">
             <ul>
@@ -15,6 +15,6 @@
                 {% endfor %}
             </ul>
         </td>
-        <td class="pattern">{{ lip.pattern.name }}</td>
+        <td class="pattern">{{ inflection.pattern.name }}</td>
     </tr>
 {% endfor %}
@@ -25,7 +25,7 @@ urlpatterns += patterns(
     url(r'^ajax/odm-forms/$', 'odm_forms'),
     url(r'^ajax/lexeme-edit-form/$', 'lexeme_edit_form'),
     url(r'^ajax/update-lexeme/$', 'update_lexeme'),
-    url(r'^ajax/new-lip-row/$', 'new_lip_edit_row'),
+    url(r'^ajax/new-inflection-row/$', 'new_inflection_edit_row'),
     url(r'^ajax/new-cr-row/$', 'new_cross_reference_row'),
     url(r'^ajax/delete-lexeme/$', 'delete_lexeme'),
     url(r'^ajax/check-pos/$', 'check_pos'),
@@ -138,7 +138,7 @@ def lexeme_view(request):
         'ajax_get_filters': reverse('get_filters'),
         'ajax_delete_filter': reverse('delete_filter'),
         'ajax_table_preview': reverse('table_preview'),
-        'ajax_new_lip_row': reverse('new_lip_edit_row'),
+        'ajax_new_inflection_row': reverse('new_inflection_edit_row'),
         'ajax_new_cr_row': reverse('new_cross_reference_row'),
         'ajax_delete_lexeme': reverse('delete_lexeme'),
         'ajax_prompter_list': reverse('prompter_list'),
@@ -51,8 +51,8 @@ ASPEKT = LexemeAttribute.objects.get(name=u&#39;aspekt&#39;)
 WLASC = LexemeAttribute.objects.get(name=u'właściwy')
  
  
-def get_charfl(lip):
-    l = lip.lexeme
+def get_charfl(inflection):
+    l = inflection.lexeme
     pos = l.part_of_speech_id
     if pos == 'adj':
         zloz = l.attribute_value(ZLOZ).value == u'obecna'
@@ -68,7 +68,7 @@ def get_charfl(lip):
     elif pos == 'pred':
         return 'qndk'
     elif pos == 'subst':
-        return lip.gender.symbol
+        return inflection.gender.symbol
     elif pos == 'v':
         wlasc = l.attribute_value(WLASC).value
         return ('q' if wlasc == 'Q' else '') + l.attribute_value(ASPEKT).value
@@ -88,14 +88,14 @@ def make_data(entry):
     nonrefl_ids, sie_ids, sobie_ids = (
         ', '.join(str(pk) for pk in refls)
         for refls in (nonrefls, sie_refls, sobie_refls))
-    lips = Inflection.objects.filter(lexeme__entry=entry)
-    if not lips:
+    inflections = Inflection.objects.filter(lexeme__entry=entry)
+    if not inflections:
         return []
     subqueries = []
     params = []
-    for lip in lips:
-        charfl = get_charfl(lip)
-        pattern = lip.pattern
+    for inflection in inflections:
+        charfl = get_charfl(inflection)
+        pattern = inflection.pattern
         fnuni = pattern.endings.filter(
             base_form_label__symbol='pl:gen:fchar').exists()
         funi = pattern.endings.filter(
@@ -118,7 +118,7 @@ def make_data(entry):
                         (l.pos not in ('v', 'pact') or
                         refl.attribute_value_id in (%s))''' % nonrefl_ids,
                 },
-                [charfl, lip.id, '1']
+                [charfl, inflection.id, '1']
             ),
             # czasowniki sięiczne:
             (
@@ -129,7 +129,7 @@ def make_data(entry):
                     'leks_clause': '''(l.pos in ('v', 'pact') and
                         refl.attribute_value_id in (%s))''' % sie_ids,
                 },
-                [charfl, lip.id, 's']
+                [charfl, inflection.id, 's']
             ),
             # czasowniki sobieiczne:
             (
@@ -140,7 +140,7 @@ def make_data(entry):
                     'leks_clause': '''(l.pos in ('v', 'pact') and
                         refl.attribute_value_id in (%s))''' % sobie_ids,
                 },
-                [charfl, lip.id, 's1']
+                [charfl, inflection.id, 's1']
             ),
             # czasowniki zanegowane:
             (
@@ -151,7 +151,7 @@ def make_data(entry):
                     'leks_clause': '''l.pos='v' and
                         refl.attribute_value_id in (%s)''' % nonrefl_ids,
                 },
-                [charfl, lip.id, 'n']
+                [charfl, inflection.id, 'n']
             ),
             # czasowniki sięiczne zanegowane:
             (
@@ -162,7 +162,7 @@ def make_data(entry):
                     'leks_clause': '''(l.pos='v' and
                         refl.attribute_value_id in (%s))''' % sie_ids,
                 },
-                [charfl, lip.id, 'ns']
+                [charfl, inflection.id, 'ns']
             ),
             # czasowniki sobieiczne zanegowane:
             (
@@ -173,7 +173,7 @@ def make_data(entry):
                     'leks_clause': '''(l.pos='v' and
                         refl.attribute_value_id in (%s))''' % sobie_ids,
                 },
-                [charfl, lip.id, 'ns1']
+                [charfl, inflection.id, 'ns1']
             ),
             # wymagające gniazdowania: adjcom, advcom i ppas
             (
@@ -185,7 +185,7 @@ def make_data(entry):
                         (l.pos != 'ppas' or refl.attribute_value_id in (%s))'''
                                    % nonrefl_ids,
                 },
-                [charfl, lip.lexeme_id]
+                [charfl, inflection.lexeme_id]
             ),
             # imiesłowy bierne czasowników sięicznych:
             (
@@ -195,7 +195,7 @@ def make_data(entry):
                     'main_clause': '''(typods ='ppasver' and l.pos ='ppas' and
                         refl.attribute_value_id in (%s))''' % sie_ids,
                 },
-                [charfl, lip.lexeme_id]
+                [charfl, inflection.lexeme_id]
             ),
             # imiesłowy bierne czasowników sobieicznych:
             (
@@ -205,7 +205,7 @@ def make_data(entry):
                     'main_clause': '''(typods ='ppasver' and l.pos ='ppas' and
                         refl.attribute_value_id in (%s))''' % sobie_ids,
                 },
-                [charfl, lip.lexeme_id]
+                [charfl, inflection.lexeme_id]
             ),
         ]
         subqueries.extend(
@@ -57,7 +57,7 @@ lexeme_attribute_order = [
     # _(u'odsyłacz'),
 ]
  
-lip_attribute_order = [
+inflection_attribute_order = [
     _(u'index'),
     _(u'inflection characteristic'),
     _(u'gender'),
@@ -96,13 +96,13 @@ def get_lexeme_attr(attr, lexeme):
             return ''
  
  
-def get_lip_attr(attr, lip):
+def get_inflection_attr(attr, inflection):
     if attr == 'oind':
-        return lip.index
+        return inflection.index
     elif attr == 'gender_id':
-        return lip.gender.symbol if lip.gender else ''
+        return inflection.gender.symbol if inflection.gender else ''
     elif attr == 'w_id':
-        return lip.pattern.name
+        return inflection.pattern.name
  
  
 def prepare_value(column, value):
@@ -139,7 +139,7 @@ def prepare_value(column, value):
     return prepared
  
  
-def lip_header(gender, pattern):
+def inflection_header(gender, pattern):
     if gender:
         return u'%s/%s ' % (gender.symbol, pattern.name)
     else:
@@ -148,13 +148,13 @@ def lip_header(gender, pattern):
  
 def transaction_table(transaction_data):
     transaction_dict = {}
-    lips = GroupDict()
+    inflections = GroupDict()
     extra_attributes = {}
     classifications = {}
     qualifiers = []
     vocabs = []
     crs = {}
-    lip_qualifiers = {}
+    inflection_qualifiers = {}
     deleted = False
     for item1 in transaction_data:
         table = item1.table_name
@@ -175,9 +175,9 @@ def transaction_table(transaction_data):
             if table not in ('odmieniasie', 'kwalifikatory_odmieniasiow'):
                 transaction_dict[attr] = before_after
             elif table == 'odmieniasie':
-                if item1.row_id not in lips:
-                    lips[item1.row_id] = {}
-                lips[item1.row_id][attr] = before_after
+                if item1.row_id not in inflections:
+                    inflections[item1.row_id] = {}
+                inflections[item1.row_id][attr] = before_after
         if column == 'attribute_value_id':
             if before:
                 value, attr = before
@@ -207,10 +207,10 @@ def transaction_table(transaction_data):
                 crs[item1.row_id] = {}
             crs[item1.row_id][column] = before_after
         if table == 'kwalifikatory_odmieniasiow':
-            if item1.row_id not in lip_qualifiers:
-                lip_qualifiers[item1.row_id] = {}
+            if item1.row_id not in inflection_qualifiers:
+                inflection_qualifiers[item1.row_id] = {}
             if column:  # stare DELETE nie będą widoczne
-                lip_qualifiers[item1.row_id][column] = before_after
+                inflection_qualifiers[item1.row_id][column] = before_after
     if deleted:
         return deleted_lexeme_table(transaction_data[0].lexeme)
     rows = []
@@ -235,7 +235,7 @@ def transaction_table(transaction_data):
             try:
                 if cr_data['l_id_do'][i] is not None:
                     l = Lexeme.all_objects.get(id=int(cr_data['l_id_do'][i]))
-                    genders = l.lip_data()['genders']
+                    genders = l.inflection_data()['genders']
                     cr_type = CrossReferenceType.objects.get(
                         pk=cr_data['typods_id'][i])
                     prepared = ' '.join((cr_type.symbol, unicode(l), genders))
@@ -245,38 +245,40 @@ def transaction_table(transaction_data):
                 prepared = None
             before_after.append(prepared)
         rows.append((attr, tuple(before_after)))
-    lip_dict = GroupDict()
-    for lip_id, lip_data in lips.iteritems():
-        for attr in lip_attribute_order:
-            if attr in lip_data:
-                lip_dict.add(lip_id, (attr, lip_data[attr]))
-    for q_data in lip_qualifiers.itervalues():
+    inflection_dict = GroupDict()
+    for inflection_id, inflection_data in inflections.iteritems():
+        for attr in inflection_attribute_order:
+            if attr in inflection_data:
+                inflection_dict.add(
+                    inflection_id, (attr, inflection_data[attr]))
+    for q_data in inflection_qualifiers.itervalues():
         if q_data:  # stare DELETE...
             attr = _(u'qualifier')
-            lip_data = q_data.get(
+            inflection_data = q_data.get(
                 'inflection_id', q_data['lexemeinflectionpattern_id'])
-            lip_id = int(lip_data[0] or lip_data[1])
-            lip_dict.add(lip_id, (attr, q_data['qualifier_id']))
-    lip_tables = []
-    for lip_id, lip_data in lip_dict.iteritems():
-        lip = Inflection.all_objects.filter(pk=lip_id)
-        if lip:
-            lip = lip[0]
-            header = lip_header(lip.gender, lip.pattern)
+            inflection_id = int(inflection_data[0] or inflection_data[1])
+            inflection_dict.add(inflection_id, (attr, q_data['qualifier_id']))
+    inflection_tables = []
+    for inflection_id, inflection_data in inflection_dict.iteritems():
+        inflection = Inflection.all_objects.filter(pk=inflection_id)
+        if inflection:
+            inflection = inflection[0]
+            header = inflection_header(inflection.gender, inflection.pattern)
         else:
             records = History.objects.filter(
-                operation='DELETE', table_name='odmieniasie', row_id=lip_id)
+                operation='DELETE', table_name='odmieniasie',
+                row_id=inflection_id)
             try:
                 gender_id = records.get(column_name='gender_id').old_value
                 pattern_id = records.get(column_name='w_id').old_value
                 gender = Gender.objects.get(id=gender_id)
                 pattern = Pattern.all_objects.get(id=pattern_id)
-                header = lip_header(gender, pattern)
+                header = inflection_header(gender, pattern)
             except ObjectDoesNotExist:  # stare DELETE...
                 header = ''
             header += force_unicode(_(u'(deleted)'))
-        lip_tables.append((header, lip_data))
-    return rows, lip_tables
+        inflection_tables.append((header, inflection_data))
+    return rows, inflection_tables
  
  
 def deleted_lexeme_table(lexeme):
@@ -302,34 +304,35 @@ def deleted_lexeme_table(lexeme):
         rows.append((attr, (
             ' '.join([
                 cr.type.symbol, cr.to_lexeme.entry,
-                cr.to_lexeme.lip_data()['genders']]),
+                cr.to_lexeme.inflection_data()['genders']]),
             None)))
     for av in lexeme.lexemeattributevalue_set.all():
         attr = av.attribute.name
         rows.append((attr, (av.value or av.display_value, None)))
-    lip_tables = []
-    for lip in lexeme.inflection_set.all():
-        lip_data = []
+    inflection_tables = []
+    for inflection in lexeme.inflection_set.all():
+        inflection_data = []
         for table, column, attr in attribute_translation_list:
             if table == 'odmieniasie' and column != 'charfl':
-                lip_data.append((attr, (get_lip_attr(column, lip), None)))
-        for q in lip.qualifiers.all():
+                inflection_data.append(
+                    (attr, (get_inflection_attr(column, inflection), None)))
+        for q in inflection.qualifiers.all():
             attr = _(u'qualifier')
-            lip_data.append((attr, (q.label, None)))
-        header = lip_header(lip.gender, lip.pattern)
-        lip_tables.append((header, lip_data))
-    return rows, lip_tables
+            inflection_data.append((attr, (q.label, None)))
+        header = inflection_header(inflection.gender, inflection.pattern)
+        inflection_tables.append((header, inflection_data))
+    return rows, inflection_tables
  
  
 def lexeme_table(transaction_data, last_tb):
-    rows, lip_tables = transaction_table(transaction_data)
+    rows, inflection_tables = transaction_table(transaction_data)
     try:
         lexeme = transaction_data[0].lexeme
     except Lexeme.DoesNotExist:
         lexeme = _(u'(deleted)')  # aktualnie niemożliwe
     return {
         'rows': rows,
-        'lip_tables': lip_tables,
+        'inflection_tables': inflection_tables,
         'user': transaction_data[0].user,
         'date': last_tb,
         'lexeme': lexeme,
@@ -20,6 +20,6 @@ table.transaction-table th {
     background-color: #E6E6FF;
 }
  
-table.transaction-table th.lip-header {
+table.transaction-table th.inflection-header {
     text-align: left;
 }
 \ No newline at end of file
@@ -6,10 +6,10 @@
         <th>{% trans 'after' %}</th>
     </tr>
     {% include "history_row.html" with rows=table.rows %}
-    {% for header, lip_rows in table.lip_tables %}
+    {% for header, inflection_rows in table.inflection_tables %}
         <tr>
-            <th colspan="3" class="lip-header">{% trans 'inflection' %} {{ header }}:</th>
+            <th colspan="3" class="inflection-header">{% trans 'inflection' %} {{ header }}:</th>
         </tr>
-        {% include "history_row.html" with rows=lip_rows %}
+        {% include "history_row.html" with rows=inflection_rows %}
     {% endfor %}
 </table>
@@ -103,7 +103,7 @@ def pattern_preview(request, id, reader=False):
         user = request.user
     if not request.user.is_authenticated() and not pattern.is_public():
         raise AjaxError('access denied')
-    lips = Inflection.filter_visible(pattern.inflection_set, user)
+    inflections = Inflection.filter_visible(pattern.inflection_set, user)
     detailed_counts = []
     pattern_filter_rule = {
         'field': 'pattern_name',
@@ -121,7 +121,7 @@ def pattern_preview(request, id, reader=False):
  
     if pattern.type.inflection_type_id == 'subst':
         for gender in Gender.objects.all():
-            gender_count = lexeme_count(lips.filter(gender=gender))
+            gender_count = lexeme_count(inflections.filter(gender=gender))
             if gender_count > 0:
                 example = pattern.get_example(gender)
                 if example:
@@ -147,7 +147,7 @@ def pattern_preview(request, id, reader=False):
     return {
         'pattern': pattern,
         'root': first_root,
-        'lexeme_count': lexeme_count(lips),
+        'lexeme_count': lexeme_count(inflections),
         'detailed_counts': detailed_counts,
         'pattern_filter_url': make_filter_url([pattern_filter_rule]),
     }
@@ -145,10 +145,10 @@ class Pattern(Model):
                 pattern=self, gender=gender)
         if examples:
             lexeme = examples.get().lexeme
-            example_lips = lexeme.inflection_set.filter(
+            example_inflections = lexeme.inflection_set.filter(
                 pattern=self, gender=gender)
-            if example_lips:
-                return lexeme, example_lips[0].root
+            if example_inflections:
+                return lexeme, example_inflections[0].root
             else:
                 return self.get_example(gender, refresh=True)
  
@@ -18,9 +18,4 @@ table.detailed-counts td, table.detailed-counts th {
 table.detailed-counts th.left-header {
     border-right-style: solid;
     text-align: left;
-}
-
-.ellipsis-icon {
-    display: block;
-    width: 16px;
 }
 \ No newline at end of file
@@ -174,11 +174,11 @@ class TableTemplate(Model):
         return self.name
  
  
-def combine_qualifiers(lip_qualifiers, e_qualifiers):
-    if not lip_qualifiers:
-        return e_qualifiers
+def combine_qualifiers(inflection_qualifiers, ending_qualifiers):
+    if not inflection_qualifiers:
+        return ending_qualifiers
     qualifiers = set()
-    for q in list(lip_qualifiers) + list(e_qualifiers):
+    for q in list(inflection_qualifiers) + list(ending_qualifiers):
         if q.exclusion_class:
             excluded = set(q.exclusion_class.qualifier_set.all())
             qualifiers -= excluded
@@ -201,7 +201,7 @@ class Cell(Model):
         return set()
  
     def forms(self, base_endings=None, separator=u'', root=u'',
-              lip_qualifiers=None, lip_index=0, qualifiers=None,
+              inflection_qualifiers=None, inflection_index=0, qualifiers=None,
               edit_view=False, span=False, depr=None, cell_qualifier=False):
         if qualifiers:
             qualifiers_set = set(qualifiers)
@@ -212,11 +212,11 @@ class Cell(Model):
             else:
                 return set(quals) & qualifiers_set
  
-        if lip_qualifiers and not edit_view:
+        if inflection_qualifiers and not edit_view:
             # l_qual = filter_quals(lexeme_qualifiers)
-            lip_qual = filter_quals(lip_qualifiers)
+            inflection_qual = filter_quals(inflection_qualifiers)
         else:
-            lip_qual = set()
+            inflection_qual = set()
         endings = base_endings[self.base_form_label]
         if span:
             form_template = (
@@ -242,11 +242,11 @@ class Cell(Model):
                 % self.get_qualifier())
         forms = [
             (
-                (self.get_index(), lip_index, ending.index),
+                (self.get_index(), inflection_index, ending.index),
                 (form_template % (
                  self.prefix, root, separator, ending.string, self.suffix)),
                 combine_qualifiers(
-                    lip_qual, filter_quals(ending.qualifiers.all())),
+                    inflection_qual, filter_quals(ending.qualifiers.all())),
             )
             for ending in endings
         ]
@@ -4,7 +4,7 @@
             <caption>
                 {{ gender.symbol }}:
                 {% if pronunciations %}
-                    <span class="lip-pronunciation">[{{ pronunciations|join:"/"|safe }}]{% if gender_qualifiers %};{% endif %}</span>
+                    <span class="inflection-pronunciation">[{{ pronunciations|join:"/"|safe }}]{% if gender_qualifiers %};{% endif %}</span>
                 {% endif %}
                 <span class="qualifiers">{{ gender_qualifiers|join:" " }}</span>
                 {% include "pattern_list.html" %}
@@ -9,7 +9,7 @@ from patterns.models import Pattern
  
  
 @render_ajax(template='table_preview.html', method='get')
-def table_preview(request, lexeme_id, lip_id, pattern, attr_data=None,
+def table_preview(request, lexeme_id, inflection_id, pattern, attr_data=None,
                   gender=None, entry=None, pos=None):
     lexeme = Lexeme.all_objects.get(pk=lexeme_id)
     if not lexeme.perm(request.user, 'view'):
@@ -28,15 +28,15 @@ def table_preview(request, lexeme_id, lip_id, pattern, attr_data=None,
                 id__in=attr_data)
         else:
             attr_vals = None
-        if lip_id.startswith('lip_add'):
-            lip = Inflection(lexeme=lexeme, index=0)
+        if inflection_id.startswith('inf_add'):
+            inflection = Inflection(lexeme=lexeme, index=0)
         else:
-            lip = Inflection.objects.get(pk=int(lip_id[3:]))
-        lip.pattern = pattern
-        lip.gender = gender
-        lip.root = lip.get_root()
+            inflection = Inflection.objects.get(pk=int(inflection_id[3:]))
+        inflection.pattern = pattern
+        inflection.gender = gender
+        inflection.root = inflection.get_root()
         qualifiers = Qualifier.visible_qualifiers(request.user)
-        table = lip.inflection_table(
+        table = inflection.table(
             '0', separated=True, qualifiers=qualifiers, edit_view=True,
             attr_vals=attr_vals, pos=part_of_speech)
         prepare_table(table)