Index: gc_lang/fr/modules/conj_generator.py
==================================================================
--- gc_lang/fr/modules/conj_generator.py
+++ gc_lang/fr/modules/conj_generator.py
@@ -1,32 +1,81 @@
-# Conjugation data
+# Conjugation generator
+# beta stage, unfinished, the root for a new way to generate flexions…
+
+import re
+
+
+def conjugate (sVerb, sVerbTag="i_____a", bVarPpas=True):
+    lConj = []
+    cGroup = getVerbGroupChar(sVerb)
+    for nCut, sAdd, sFlexTags, sPattern in getConjRules(sVerb):
+        if not sPattern or re.search(sPattern, sVerb):
+            lConj.append((sVerb[0:-nCut]+sAdd, ":V" + cGroup + "_" + sVerbTag + sFlexTags))
+    return lConj
+
 
-# beta stage, unfinished, may be useless or the root for a new way to generate flexions…
+def getVerbGroupChar (sVerb, ):
+    sVerb = sVerb.lower()
+    if sVerb.endswith("er"):
+        return "1"
+    if sVerb.endswith("ir"):
+        return "2"
+    if sVerb == "être" or sVerb == "avoir":
+        return "0"
+    if sVerb.endswith("re"):
+        return "3"
+    return "4"
+
 
-# Règles de conjugaison
+def getConjRules (sVerb, bVarPpas=True, nGroup=2):
+    if sVerb.endswith("er"):
+        # premier groupe, conjugaison en fonction de la terminaison du lemme
+        # 5 lettres
+        if sVerb[-5:] in oConj["V1"]:
+            lConj = oConj["V1"][sVerb[-5:]]
+        # 4 lettres
+        elif sVerb[-4:] in oConj["V1"]:
+            if sVerb.endswith(("eler", "eter")):
+                lConj = oConj["V1"][sVerb[-4:]]["1"]
+            lConj = oConj["V1"][sVerb[-4:]]
+        # 3 lettres
+        elif sVerb[-3:] in oConj["V1"]:
+            lConj = oConj["V1"][sVerb[-3:]]
+        else:
+            lConj = oConj["V1"]["er"]
+        lConj.extend(oConj["V1_ppas"][bVarPpas])
+    elif sVerb.endswith("ir") and nGroup <= 2:
+        # deuxième groupe
+        lConj = oConj["V2"]
+        lConj.extend(oConj["V2_ppas"][bVarPpas])
+    else:
+        # TODO: troisième groupe
+        lConj = [ [0, "", ":Y/*", false] ]
+    return lConj
+
 
 oConj = {
     "V1_ppas": {
-        "var": [
+        True: [
             [2,     "é",           ":Q:A:1ŝ:m:s/*",     False],
             [2,     "és",          ":Q:A:m:p/*",        False],
             [2,     "ée",          ":Q:A:f:s/*",        False],
             [2,     "ées",         ":Q:A:f:p/*",        False],
         ],
-        "invar": [
+        False: [
             [2,     "é",           ":Q:e:i/*",          False],
         ]
     },
 
     "V2_ppas": {
-        "var": [
+        True: [
             [2,     "i",           ":Q:A:m:s/*",        False],
             [2,     "is",          ":Q:A:m:p/*",        False],
             [2,     "ie",          ":Q:A:f:s/*",        False],
             [2,     "ies",         ":Q:A:f:p/*",        False],
         ],
-        "invar": [
+        False: [
             [2,     "i",           ":Q:e:i/*",          False],
         ]
     },
 
     # deuxième groupe (le seul groupe régulier)

Index: gc_lang/fr/oxt/DictOptions/LexiconEditor.py
==================================================================
--- gc_lang/fr/oxt/DictOptions/LexiconEditor.py
+++ gc_lang/fr/oxt/DictOptions/LexiconEditor.py
@@ -399,22 +399,13 @@
                     c_aa = "a"  if self.xV_aa.State  else "_"
                     sVerbTag = c_i + c_t + c_n + c_p + c_m + c_ae + c_aa
                     if not sVerbTag.endswith("__") and not sVerbTag.startswith("____"):
                         sVerbPattern = self.xVpattern.Text.strip()
                         if not sVerbPattern:
-                            if sLemma.endswith("er") or sLemma.endswith("ir"):
-                                # tables de conjugaison du 1er et du 2e groupe
-                                cGroup = "1"  if sLemma.endswith("er")  else "2"
-                                for nCut, sAdd, sFlexTags, sPattern in self._getConjRules(sLemma):
-                                    if not sPattern or re.search(sPattern, sLemma):
-                                        self.lGeneratedFlex.append((sLemma[0:-nCut]+sAdd, sLemma, ":V" + cGroup + "_" + sVerbTag + sFlexTags))
-                                # participes passés
-                                bPpasVar = "var"  if self.xV_pp.State  else "invar"
-                                lPpasRules = conjgen.oConj["V1_ppas"][bPpasVar]  if sLemma.endswith("er")  else conjgen.oConj["V2_ppas"][bPpasVar]
-                                for nCut, sAdd, sFlexTags, sPattern in lPpasRules:
-                                    if not sPattern or re.search(sPattern, sLemma):
-                                        self.lGeneratedFlex.append((sLemma[0:-nCut]+sAdd, sLemma, ":V" + cGroup + "_" + sVerbTag + sFlexTags))
+                            # Utilisation du générateur de conjugaison
+                            for sFlexion, sFlexTags in conjgen.conjugate(sLemma, sVerbTag, bool(self.xV_pp.State)):
+                                self.lGeneratedFlex.append((sFlexion, sLemma, sFlexTags))
                         else:
                             # copie du motif d’un autre verbe : utilisation du conjugueur
                             if conj.isVerb(sVerbPattern):
                                 oVerb = conj.Verb(sLemma, sVerbPattern)
                                 for sTag1, dFlex in oVerb.dConj.items():
@@ -444,32 +435,10 @@
                 sTags = self.xTags.Text.strip()
                 if sFlexion and sTags.startswith(":"):
                     self.lGeneratedFlex.append((sFlexion, sLemma, sTags))
         self._showGenWords()
 
-    def _getConjRules (self, sVerb):
-        if sVerb.endswith("ir"):
-            # deuxième groupe
-            return conjgen.oConj["V2"]
-        elif sVerb.endswith("er"):
-            # premier groupe, conjugaison en fonction de la terminaison du lemme
-            # 5 lettres
-            if sVerb[-5:] in conjgen.oConj["V1"]:
-                return conjgen.oConj["V1"][sVerb[-5:]]
-            # 4 lettres
-            if sVerb[-4:] in conjgen.oConj["V1"]:
-                if sVerb.endswith(("eler", "eter")):
-                    return conjgen.oConj["V1"][sVerb[-4:]]["1"]
-                return conjgen.oConj["V1"][sVerb[-4:]]
-            # 3 lettres
-            if sVerb[-3:] in conjgen.oConj["V1"]:
-                return conjgen.oConj["V1"][sVerb[-3:]]
-            return conjgen.oConj["V1"]["er"]
-        else:
-            # troisième groupe
-            return [ [0, "", ":Y/*", false] ]
-
     def _showGenWords (self):
         xGridDataModel = self.xGridModelNew.GridDataModel
         xGridDataModel.removeAllRows()
         if not self.lGeneratedFlex:
             self.xAdd.Enabled = False