From: pascale.noyret
Date: Tue, 19 Dec 2017 13:50:10 +0000 (+0100)
Subject: merge avec la version de decembre sur la 9
X-Git-Tag: EficasTUIV0~11
X-Git-Url: http://git.salome-platform.org/gitweb/?a=commitdiff_plain;h=e8bd4e19ec3a802d4b676586e1c8e454843c91af;p=tools%2Feficas.git
merge avec la version de decembre sur la 9
---
diff --git a/Editeur/Eficas_utils.py b/Editeur/Eficas_utils.py
index df1880b9..89c601c5 100644
--- a/Editeur/Eficas_utils.py
+++ b/Editeur/Eficas_utils.py
@@ -27,7 +27,7 @@ import codecs,types
from Extensions.i18n import tr
-def substract_list(liste1,liste2):
+def substractList(liste1,liste2):
"""
Enleve tous les elements de liste2 presents dans liste1 et retourne liste1
"""
@@ -38,7 +38,7 @@ def substract_list(liste1,liste2):
pass
return liste1
-def get_rep_user(dir):
+def getRepUser(dir):
"""
Determine sur quelle plate-forme s'execute Eficas et recherche
le repertoire de l'utilisateur /$home/Eficas_install
@@ -92,7 +92,7 @@ def stripPath(pathAndFile):
""" Return filename.ext if path/filename.ext is given """
return os.path.split(pathAndFile)[1]
-def init_rep_cata_dev(fic_cata,rep_goal):
+def initRep_CataDev(fic_cata,rep_goal):
"""
Initialise le repertoire des catalogues developpeurs (chemin d'acces donne
dans le fichier eficas.ini cad :
@@ -106,7 +106,7 @@ def init_rep_cata_dev(fic_cata,rep_goal):
try :
if not os.path.isdir(rep_goal) :
os.mkdir(rep_goal)
- #texte_entete = get_entete_cata(fic_cata)
+ #texte_entete = getEnteteCata(fic_cata)
texte_entete=""
# rep_goal doit contenir les catalogues du developpeur sous la forme *.capy
# il faut creer le catalogue developpeur par concatenation de entete,declaration_concepts
@@ -127,7 +127,7 @@ def init_rep_cata_dev(fic_cata,rep_goal):
traceback.print_exc()
print ( tr("Impossible de transferer les fichiers requis dans : %s", str(rep_goal)))
-def get_entete_cata(fic_cata):
+def getEnteteCata(fic_cata):
""" Retrouve l'entete du catalogue """
l_lignes = open(fic_cata,'r').readlines()
txt = ''
diff --git a/Editeur/Objecttreeitem.py b/Editeur/Objecttreeitem.py
index 09369dc2..e9e2748f 100644
--- a/Editeur/Objecttreeitem.py
+++ b/Editeur/Objecttreeitem.py
@@ -33,7 +33,7 @@ from six.moves.reprlib import Repr
from copy import copy,deepcopy
# import du chargeur de composants
-from .comploader import make_objecttreeitem
+from .comploader import makeObjecttreeitem
from Ihm import CONNECTOR
from Extensions.i18n import tr
from Extensions.eficas_exception import EficasException
@@ -65,29 +65,29 @@ class TreeItem(object):
def __init__(self):
"""Constructor. Do whatever you need to do."""
- def GetText(self):
+ def getText(self):
"""Return text string to display."""
- def GetLabelText(self):
+ def getLabelText(self):
"""Return label text string to display in front of text (if any)."""
expandable = None
- def _IsExpandable(self):
+ def _isExpandable(self):
"""Do not override! Called by TreeNode."""
if self.expandable is None:
- self.expandable = self.IsExpandable()
+ self.expandable = self.isExpandable()
return self.expandable
- def IsExpandable(self):
+ def isExpandable(self):
"""Return whether there are subitems."""
return 1
- def _GetSubList(self):
+ def _getSubList(self):
"""Do not override! Called by TreeNode."""
- if not self.IsExpandable():
+ if not self.isExpandable():
return []
- sublist = self.GetSubList()
+ sublist = self.getSubList()
if not sublist:
self.expandable = 0
return sublist
@@ -98,13 +98,13 @@ class TreeItem(object):
def SetText(self, text):
"""Change the item's text (if it is editable)."""
- def GetIconName(self):
+ def getIconName(self):
"""Return name of icon to be displayed normally."""
def GetSelectedIconName(self):
"""Return name of icon to be displayed when selected."""
- def GetSubList(self):
+ def getSubList(self):
"""Return list of items forming sublist."""
def OnDoubleClick(self):
@@ -143,7 +143,7 @@ class Delegate(object):
class ObjectTreeItem(TreeItem,Delegate):
- def __init__(self, appli, labeltext, object, setfunction=None):
+ def __init__(self, appli, labeltext, object, setFunction=None):
self.labeltext = labeltext
self.appli = appli
# L'objet delegue est stocke dans l'attribut object
@@ -156,7 +156,7 @@ class ObjectTreeItem(TreeItem,Delegate):
# On cache l'objet initial (pour destruction eventuelle
# ulterieure)
self._object = object
- self.setfunction = setfunction
+ self.setFunction = setFunction
self.expandable = 1
self.sublist=[]
self.init()
@@ -182,11 +182,11 @@ class ObjectTreeItem(TreeItem,Delegate):
object = self._object.copy()
appli = copy(self.appli)
labeltext = copy(self.labeltext)
- fonction = deepcopy(self.setfunction)
- item = make_objecttreeitem(appli,labeltext,object,fonction)
+ fonction = deepcopy(self.setFunction)
+ item = makeObjecttreeitem(appli,labeltext,object,fonction)
return item
- def isactif(self):
+ def isActif(self):
if hasattr(self.object,'actif'):
return self.object.actif
else:
@@ -199,7 +199,7 @@ class ObjectTreeItem(TreeItem,Delegate):
"""
pass
- def GetLabelText(self):
+ def getLabelText(self):
""" Retourne 3 valeurs :
- le texte a afficher dans le noeud representant l'item
- la fonte dans laquelle afficher ce texte
@@ -208,21 +208,21 @@ class ObjectTreeItem(TreeItem,Delegate):
# None --> fonte et couleur par defaut
return self.labeltext,None,None
- def get_nature(self) :
+ def getNature(self) :
"""
Retourne la nature de l'item et de l'objet
"""
return self.object.nature
- def get_regles(self):
+ def getRegles(self):
""" retourne les regles de l'objet pointe par self """
- return self.object.get_regles()
+ return self.object.getRegles()
- def get_liste_mc_presents(self):
+ def getListeMcPresents(self):
""" Retourne la liste des mots-cles fils de l'objet pointe par self """
- return self.object.liste_mc_presents()
+ return self.object.listeMcPresents()
- def get_val(self):
+ def getVal(self):
""" Retourne le nom de la valeur de l'objet pointe par self dans le cas
ou celle-ci est un objet (ASSD) """
return self.object.getval()
@@ -233,45 +233,45 @@ class ObjectTreeItem(TreeItem,Delegate):
"""
return self.object.definition
- def get_liste_mc_ordonnee(self,liste,dico):
+ def getListeMcOrdonnee(self,liste,dico):
""" retourne la liste ordonnee (suivant le catalogue) brute des mots-cles
d'une entite composee dont le chemin complet est donne sous forme
d'une liste du type :ETAPE + MCFACT ou MCBLOC + ...
il faut encore rearranger cette liste (certains mots-cles deja
presents ne doivent plus etre proposes, regles ...)"""
- return self.object.get_liste_mc_ordonnee(liste,dico)
+ return self.object.getListeMcOrdonnee(liste,dico)
- def get_liste_mc_ordonnee_brute(self,liste,dico):
+ def getListeMcOrdonnee_brute(self,liste,dico):
"""
retourne la liste ordonnee (suivant le catalogue) BRUTE des mots-cles
d'une entite composee dont le chemin complet est donne sous forme
d'une liste du type :ETAPE + MCFACT ou MCBLOC + ...
"""
- return self.object.get_liste_mc_ordonnee_brute(liste,dico)
+ return self.object.getListeMcOrdonnee_brute(liste,dico)
- def get_genealogie(self):
+ def getGenealogie(self):
"""
Retourne la liste des noms des ascendants (noms de MCSIMP,MCFACT,MCBLOC ou ETAPE)
de l'objet pointe par self
"""
- return self.object.get_genealogie()
+ return self.object.getGenealogie()
- def get_index_child(self,nom_fils):
+ def getIndex_child(self,nom_fils):
"""
Retourne l'index dans la liste des fils de self du nouveau fils de nom nom_fils
Necessaire pour savoir a quelle position dans la liste des fils il faut ajouter
le nouveau mot-cle
"""
- return self.object.get_index_child(nom_fils)
+ return self.object.getIndex_child(nom_fils)
- def get_index_child_old(self,nom_fils):
+ def getIndex_child_old(self,nom_fils):
"""
Retourne l'index dans la liste des fils de self du nouveau fils de nom nom_fils
Necessaire pour savoir a quelle position dans la liste des fils il faut ajouter
le nouveau mot-cle
"""
- liste_noms_mc_ordonnee = self.get_liste_mc_ordonnee_brute(self.get_genealogie(),self.get_jdc().cata_ordonne_dico)
- liste_noms_mc_presents = self.object.liste_mc_presents()
+ liste_noms_mc_ordonnee = self.getListeMcOrdonnee_brute(self.getGenealogie(),self.getJdc().cata_ordonne_dico)
+ liste_noms_mc_presents = self.object.listeMcPresents()
l=[]
for nom in liste_noms_mc_ordonnee:
if nom in liste_noms_mc_presents or nom == nom_fils:
@@ -279,24 +279,24 @@ class ObjectTreeItem(TreeItem,Delegate):
# l contient les anciens mots-cles + le nouveau dans l'ordre
return l.index(nom_fils)
- def append_child(self,name,pos=None):
+ def appendChild(self,name,pos=None):
"""
Permet d'ajouter un item fils a self
"""
if pos == 'first':
index = 0
elif pos == 'last':
- index = len(self.liste_mc_presents())
+ index = len(self.listeMcPresents())
elif type(pos) == int :
# la position est fixee
index = pos
elif type(pos) == types.InstanceType:
# pos est un item. Il faut inserer name apres pos
- index = self.get_index(pos) +1
+ index = self.getIndex(pos) +1
elif type(name) == types.InstanceType:
- index = self.get_index_child(name.nom)
+ index = self.getIndex_child(name.nom)
else:
- index = self.get_index_child(name)
+ index = self.getIndex_child(name)
return self.addobject(name,index)
def appendBrother(self,name,pos='after'):
@@ -304,7 +304,7 @@ class ObjectTreeItem(TreeItem,Delegate):
Permet d'ajouter un frere a self
par defaut on l'ajoute apres self
"""
- index = self._object.parent.get_index(self.getObject())
+ index = self._object.parent.getIndex(self.getObject())
if pos == 'before':
index = index
elif pos == 'after':
@@ -314,15 +314,11 @@ class ObjectTreeItem(TreeItem,Delegate):
return
return self.parent.addobject(name,index)
- def get_nom_etape(self):
- """Retourne le nom de self """
- return self.object.get_nom_etape()
-
- def get_copie_objet(self):
+ def getCopieObjet(self):
""" Retourne une copie de l'objet pointe par self """
return self.object.copy()
- def get_position(self):
+ def getPosition(self):
""" Retourne la valeur de l'attribut position de l'objet pointe par self """
definition = self.get_definition()
try:
@@ -330,79 +326,79 @@ class ObjectTreeItem(TreeItem,Delegate):
except AttributeError:
return 'local'
- def get_nom(self):
+ def getNom(self):
""" Retourne le nom de l'objet pointe par self """
return self.object.nom
- def get_jdc(self):
+ def getJdc(self):
""" Retourne le jdc auquel appartient l'objet pointe par self """
return self.object.jdc
- def get_valeur(self):
+ def getValeur(self):
""" Retourne la valeur de l'objet pointe par self """
return self.object.valeur
- def get_cr(self):
+ def getCr(self):
""" Retourne le compte-rendu CR de self """
return self.object.report()
- def get_objet_commentarise(self):
+ def getObjetCommentarise(self):
"""
Cette methode retourne un objet commentarise
representatif de self.object
--> a surcharger par les differents items
"""
raise EficasException("MESSAGE AU DEVELOPPEUR : il faut \
- surcharger la methode get_objet_commentarise() \
+ surcharger la methode getObjetCommentarise() \
pour la classe %s", self.__class__.__name__)
- def isvalid(self):
+ def isValid(self):
""" Retourne 1 si l'objet pointe par self est valide, 0 sinon"""
- return self.object.isvalid()
+ return self.object.isValid()
- def iscopiable(self):
+ def isCopiable(self):
"""
Retourne 1 si l'objet est copiable, 0 sinon
Par defaut retourne 0
"""
return 0
- def get_mc_presents(self):
+ def getMcPresents(self):
""" Retourne le dictionnaire des mots-cles presents de l'objet pointe par self """
return self.object.dict_mc_presents()
- def verif_condition_regles(self,l_mc_presents):
- return self.object.verif_condition_regles(l_mc_presents)
+ def verifConditionRegles(self,l_mc_presents):
+ return self.object.verifConditionRegles(l_mc_presents)
- def get_fr(self):
+ def getFr(self):
""" Retourne le fr de l'objet pointe par self """
try:
- return self.object.get_fr()
+ return self.object.getFr()
except:
return ""
- def get_docu(self):
+ def getDocu(self):
""" Retourne la cle de doc de l'objet pointe par self """
- return self.object.get_docu()
+ return self.object.getDocu()
- def set_valeur(self,new_valeur):
+ def setValeur(self,new_valeur):
""" Remplace la valeur de l'objet pointe par self par new_valeur """
- return self.object.set_valeur(new_valeur)
+ return self.object.setValeur(new_valeur)
- def GetText(self):
+ def getText(self):
return myrepr.repr(self.object)
- def GetIconName(self):
- if not self.IsExpandable():
+ def getIconName(self):
+ if not self.isExpandable():
return "python"
def IsEditable(self):
- return self.setfunction is not None
+ return self.setFunction is not None
def SetText(self, text):
try:
value = eval(text)
- self.setfunction(value)
+ self.setFunction(value)
except:
pass
# Modif de ma part CCar : je ne comprend pas a quoi ca sert
@@ -410,10 +406,10 @@ class ObjectTreeItem(TreeItem,Delegate):
# else:
# self.object = value
- def IsExpandable(self):
+ def isExpandable(self):
return 1
- def GetSubList(self):
+ def getSubList(self):
keys = dir(self.object)
sublist = []
for key in keys:
@@ -421,7 +417,7 @@ class ObjectTreeItem(TreeItem,Delegate):
value = getattr(self.object, key)
except AttributeError:
continue
- item = make_objecttreeitem(
+ item = makeObjecttreeitem(
self.appli,
str(key) + " =",
value,
@@ -430,27 +426,28 @@ class ObjectTreeItem(TreeItem,Delegate):
sublist.append(item)
return sublist
- def wait_fichier_init(self):
+ # a piori inutile PN 06 11 17
+ #def wait_fichier_init(self):
""" Retourne 1 si l'object pointe par self attend un fichier d'initialisation
(ex: macros POURSUITE et INCLUDE de Code_Aster), 0 SINON """
- return self.object.definition.fichier_ini
+ # return self.object.definition.fichier_ini
- def make_objecttreeitem(self,appli,labeltext, object, setfunction=None):
+ def makeObjecttreeitem(self,appli,labeltext, object, setFunction=None):
"""
Cette methode, globale pour les objets de type item, permet de construire et de retourner un objet
de type item associe a l'object passe en argument.
"""
- return make_objecttreeitem(appli,labeltext,object,setfunction)
+ return makeObjecttreeitem(appli,labeltext,object,setFunction)
#def __del__(self):
# print "__del__",self
class AtomicObjectTreeItem(ObjectTreeItem):
- def IsExpandable(self):
+ def isExpandable(self):
return 0
class SequenceTreeItem(ObjectTreeItem):
- def IsExpandable(self):
+ def isExpandable(self):
return len(self._object) > 0
def __len__(self) :
@@ -459,40 +456,40 @@ class SequenceTreeItem(ObjectTreeItem):
def keys(self):
return list(range(len(self._object)))
- def GetIconName(self):
- if self._object.isvalid():
+ def getIconName(self):
+ if self._object.isValid():
return "ast-green-los"
- elif self._object.isoblig():
+ elif self._object.isOblig():
return "ast-red-los"
else:
return "ast-yel-los"
- def ajout_possible(self):
- return self._object.ajout_possible()
+ def ajoutPossible(self):
+ return self._object.ajoutPossible()
- def get_index(self,child):
+ def getIndex(self,child):
""" Retourne le numero de child dans la liste des enfants de self """
- return self._object.get_index(child.getObject())
+ return self._object.getIndex(child.getObject())
- def GetText(self):
+ def getText(self):
return " "
- def additem(self,obj,pos):
+ def addItem(self,obj,pos):
self._object.insert(pos,obj)
- item = self.make_objecttreeitem(self.appli, obj.nom + ":", obj)
+ item = self.makeObjecttreeitem(self.appli, obj.nom + ":", obj)
return item
- def suppitem(self,item):
+ def suppItem(self,item):
try :
self._object.remove(item.getObject())
# la liste peut etre retournee vide !
message = "Mot-clef " + item.getObject().nom + " supprime"
- self.appli.affiche_infos(message)
+ self.appli.afficheInfos(message)
return 1
except:
return 0
- def GetSubList(self):
+ def getSubList(self):
isublist=iter(self.sublist)
liste=self._object.data
iliste=iter(liste)
@@ -507,9 +504,9 @@ class SequenceTreeItem(ObjectTreeItem):
for obj in iliste:
if obj is old_obj:break
# nouvel objet : on cree un nouvel item
- def setfunction(value, object=obj):
+ def setFunction(value, object=obj):
object=value
- it = self.make_objecttreeitem(self.appli, obj.nom + " : ", obj, setfunction)
+ it = self.makeObjecttreeitem(self.appli, obj.nom + " : ", obj, setFunction)
self.sublist.append(it)
if old_obj is None and obj is None:break
if old_obj is obj: self.sublist.append(item)
diff --git a/Editeur/TroisDPal.py b/Editeur/TroisDPal.py
index e73d7454..95760879 100644
--- a/Editeur/TroisDPal.py
+++ b/Editeur/TroisDPal.py
@@ -43,7 +43,7 @@ class TroisDPilote(object):
if format in generator.plugins :
# Le generateur existe on l'utilise
g=generator.plugins[format]()
- g.init_jdc(self.node.get_jdc())
+ g.init_jdc(self.node.getJdc())
texte=g.gener(self.node)
else:
print ("Le generateur n'a pas ete trouve")
diff --git a/Editeur/analyse_catalogue.py b/Editeur/analyse_catalogue.py
index 90477500..5010a3c5 100644
--- a/Editeur/analyse_catalogue.py
+++ b/Editeur/analyse_catalogue.py
@@ -34,7 +34,7 @@ from Noyau.N_CR import CR
from six.moves import range
#
-__Id__="$Id: analyse_catalogue.py,v 1.9.8.1.2.1.2.6 2014-01-23 09:14:44 pnoyret Exp $"
+__Id__="$Id: analyseCatalogue.py,v 1.9.8.1.2.1.2.6 2014-01-23 09:14:44 pnoyret Exp $"
__version__="$Name: $"
#
l_noms_commandes = ['OPER','PROC','MACRO','FORM']
@@ -42,20 +42,20 @@ l_noms_composes=['FACT','BLOC','NUPL','FORM']
l_noms_simples=['SIMP',]
l_noms=l_noms_composes+l_noms_simples
-def elimine_commentaires(text):
+def elimineCommentaires(text):
""" Elimine les lignes de commentaires dans text
Attention : supprime sauvagement tous les caracteres entre # et le retour chariot ..."""
comments = re.compile(r'#[^\n]*')
return comments.sub(u'',text)
-def cherche_nom(text):
+def chercheNom(text):
Whitespace = r'[ \f\t]*'
Name = r'[a-zA-Z_]\w*'
myexpr = '(u'+Name+')'+Whitespace+'='+Whitespace+'$'
a=re.search(myexpr,text)
return a.group(1)
-def cherche_args(text):
+def chercheArgs(text):
text = text.strip()
longueur = len(text)
if text[0] != '(u':
@@ -89,9 +89,9 @@ class ENTITE(object):
reste=liste[1]
reste = reste.strip()
if reste[0:4] in l_noms :
- nom_mc = cherche_nom(arg1+'=')
- arg_mc, self.text = cherche_args(reste[4:])
- self.cree_mc(nom_mc,arg_mc,reste[0:4])
+ nom_mc = chercheNom(arg1+'=')
+ arg_mc, self.text = chercheArgs(reste[4:])
+ self.creeMc(nom_mc,arg_mc,reste[0:4])
else :
self.text = reste
self.cherche_enfants()
@@ -101,7 +101,7 @@ class ENTITE(object):
except Exception as e:
self.cr.fatal(tr("Erreur rencontree dans recherche_enfants : %s", e.__str()))
- def cree_mc(self,nom_mc,arg_mc,test):
+ def creeMc(self,nom_mc,arg_mc,test):
if test in l_noms_composes :
mc = FACT_CATA(nom_mc,arg_mc,self)
self.children.append(mc)
@@ -111,7 +111,7 @@ class ENTITE(object):
else :
print (tr("Erreur dans la creation du mot-cle : %s", nom_mc) )
- def construit_liste_dico(self):
+ def construitListeDico(self):
l=[]
d={}
if len(self.children)==0:
@@ -137,7 +137,7 @@ class COMMANDE_CATA(ENTITE) :
self.cr.debut = "Debut commande %s" %self.nom
self.cr.fin = "Fin commande %s" %self.nom
self.cherche_enfants()
- self.construit_liste_dico()
+ self.construitListeDico()
parent.cr.add(self.cr)
def affiche(self):
@@ -169,7 +169,7 @@ class FACT_CATA(ENTITE) :
self.cr.debut = "Debut mot-cle facteur ou bloc %s" %self.nom
self.cr.fin = "Fin mot-cle facteur ou bloc %s" %self.nom
self.cherche_enfants()
- self.construit_liste_dico()
+ self.construitListeDico()
parent.cr.add(self.cr)
def affiche(self,ind):
@@ -200,14 +200,14 @@ class CATALOGUE_CATA(object):
print((tr("Impossible d'ouvrir le fichier : %s ", str(self.fichier))))
self.cr.fatal(tr("Impossible d'ouvrir le fichier : %s ", str(self.fichier)))
- def constr_list_txt_cmd(self,text):
- text = elimine_commentaires(text)
+ def constrListTxtCmd(self,text):
+ text = elimineCommentaires(text)
pattern = '\) *;'
liste=re.split(pattern,text)
for i in range(0,len(liste)-1):
self.liste_textes_commandes.append(liste[i]+')')
- def analyse_commande_old(self,text):
+ def analyseCommandeOld(self,text):
liste = re.split(u'OPER *\(u',text,1)
if len(liste) < 2 :
liste = re.split(u'PROC *\(u',text,1)
@@ -220,16 +220,16 @@ class CATALOGUE_CATA(object):
return
debut = liste[0]
fin = liste[1]
- nom_cmd = cherche_nom(debut)
+ nom_cmd = chercheNom(debut)
if nom_cmd == 'erreur !':
print((tr("Erreur dans la recherche du nom de la commande : "), debut))
- args_cmd,toto = cherche_args(u'(u'+fin)
+ args_cmd,toto = chercheArgs(u'(u'+fin)
if args_cmd == 'erreur !':
print((tr("Erreur dans la recherche des args de la commande :") , debut))
cmd=COMMANDE_CATA(nom_cmd,args_cmd,self)
self.liste_commandes.append(cmd)
- def analyse_commande(self,text):
+ def analyseCommande(self,text):
for nom_cmd in l_noms_commandes:
liste = re.split(nom_cmd+' *\(u',text,1)
if len(liste) == 2 : break
@@ -241,18 +241,18 @@ class CATALOGUE_CATA(object):
return
debut = liste[0]
fin = liste[1]
- nom_cmd = cherche_nom(debut)
+ nom_cmd = chercheNom(debut)
if nom_cmd == 'erreur !':
print(( tr("Erreur dans la recherche du nom de la commande : "), debut))
- args_cmd,toto = cherche_args(u'(u'+fin)
+ args_cmd,toto = chercheArgs(u'(u'+fin)
if args_cmd == 'erreur !':
print(( tr("Erreur dans la recherche des args de la commande : "), debut))
print((tr(fin)))
cmd=COMMANDE_CATA(nom_cmd,args_cmd,self)
self.liste_commandes.append(cmd)
- def analyse_texte(self,texte):
- self.constr_list_txt_cmd(texte)
+ def analyseTexte(self,texte):
+ self.constrListTxtCmd(texte)
try:
self.parent.configure_barre(len(self.liste_textes_commandes))
except:
@@ -262,16 +262,16 @@ class CATALOGUE_CATA(object):
self.parent.update_barre()
except:
pass
- self.analyse_commande(texte_commande)
- self.construit_liste_dico()
+ self.analyseCommande(texte_commande)
+ self.construitListeDico()
- def ecrit_lcmd(self):
+ def ecritLcmd(self):
f=open(u'U:\\EFICAS\\Accas\\cata.txt','w')
for cmd in self.liste_commandes :
f.write(cmd.affiche())
f.close()
- def construit_liste_dico(self):
+ def construitListeDico(self):
l=[]
d={}
for cmd in self.liste_commandes:
@@ -284,26 +284,26 @@ class CATALOGUE_CATA(object):
""" retourne l'objet rapport du catalogue de commande """
return self.cr
-def analyse_catalogue(parent,nom_cata):
+def analyseCatalogue(parent,nom_cata):
cata = CATALOGUE_CATA(parent,nom_cata)
- cata.analyse_texte(cata.texte_complet)
+ cata.analyseTexte(cata.texte_complet)
return cata
-def analyse_catalogue_commande(parent,nom_cata):
+def analyseCatalogue_commande(parent,nom_cata):
cata = CATALOGUE_CATA(parent,nom_cata)
- cata.analyse_commande(cata.texte_complet)
- cata.construit_liste_dico()
+ cata.analyseCommande(cata.texte_complet)
+ cata.construitListeDico()
return cata
-def make_cata_pickle(fic_cata):
+def makeCataPickle(fic_cata):
"""
Lance l'analyse de l'ordre des mots-cles dans le catalogue dont le nom
est passe en argument et sauvegarde ces infos dans le fichier pickle relu
par Eficas
"""
fic_cata_p = os.path.splitext(fic_cata)[0]+'_pickled.py'
- cata_ordonne = analyse_catalogue(None,fic_cata)
+ cata_ordonne = analyseCatalogue(None,fic_cata)
f = open(fic_cata_p,'w+')
p = six.moves.cPickle.Pickler(f)
p.dump(cata_ordonne.entites)
@@ -311,7 +311,7 @@ def make_cata_pickle(fic_cata):
if __name__ == "__main__" :
import profile
- profile.run(u"analyse_catalogue(None,'U:\\EFICAS\\Cata\\cata_saturne.py')")
+ profile.run(u"analyseCatalogue(None,'U:\\EFICAS\\Cata\\cata_saturne.py')")
diff --git a/Editeur/analyse_catalogue_initial.py b/Editeur/analyse_catalogue_initial.py
index 9faf2851..ee93fd57 100644
--- a/Editeur/analyse_catalogue_initial.py
+++ b/Editeur/analyse_catalogue_initial.py
@@ -28,7 +28,7 @@ import re,os
from Extensions.i18n import tr
#
-__Id__="$Id: analyse_catalogue_initial.py,v 1.2.4.1.2.2.2.4 2017-04-09 14:04:44 pnoyret Exp $"
+__Id__="$Id: analyseCatalogue_initial.py,v 1.2.4.1.2.2.2.4 2017-04-09 14:04:44 pnoyret Exp $"
__version__="$Name: V7_main $"
#
@@ -39,7 +39,7 @@ class Catalogue_initial(object):
self.lignes=[]
self.fichier=fichier
self.ouvrir_fichier()
- self.constr_list_txt_cmd()
+ self.constrListTxtCmd()
def ouvrir_fichier(self):
try :
@@ -49,7 +49,7 @@ class Catalogue_initial(object):
except :
print(tr("Impossible d'ouvrir le fichier : %s", str(self.fichier)))
- def constr_list_txt_cmd(self):
+ def constrListTxtCmd(self):
pattern = '^# Ordre Catalogue '
for i in self.lignes :
if (re.search(pattern,i)):
@@ -58,14 +58,14 @@ class Catalogue_initial(object):
self.liste_commandes.append(i)
-def analyse_catalogue(nom_cata):
+def analyseCatalogue(nom_cata):
cata = Catalogue_initial(nom_cata)
return cata.liste_commandes
if __name__ == "__main__" :
monCata="/local/noyret/Install_Eficas/EficasQT4/Openturns_StudyOpenTURNS_Cata_Study_V4.py"
- analyse_catalogue(monCata)
+ analyseCatalogue(monCata)
diff --git a/Editeur/autre_analyse_cata.py b/Editeur/autre_analyse_cata.py
index 9d4d6f17..0848eb14 100644
--- a/Editeur/autre_analyse_cata.py
+++ b/Editeur/autre_analyse_cata.py
@@ -31,7 +31,7 @@ if __name__ == "__main__" :
from Accas import NUPL
-def traite_entiteNUPL(entite):
+def traiteEntiteNUPL(entite):
"""
Fonction speciale pour les nuplets (classe NUPL)
Cette fonction ajoute a l'objet entite un attribut de nom ordre_mc
@@ -39,7 +39,7 @@ def traite_entiteNUPL(entite):
"""
entite.ordre_mc=[]
-def traite_entite(entite,liste_simp_reel):
+def traiteEntite(entite,liste_simp_reel):
"""
Cette fonction ajoute a l'objet entite un attribut de nom ordre_mc
qui est une liste contenant le nom des sous entites dans l'ordre
@@ -52,16 +52,16 @@ def traite_entite(entite,liste_simp_reel):
l=[]
for k,v in list(entite.entites.items()):
if isinstance(v,NUPL):
- traite_entiteNUPL(v)
+ traiteEntiteNUPL(v)
else:
- traite_reel(v,liste_simp_reel)
- traite_entite(v,liste_simp_reel)
- traite_cache(v)
+ traiteReel(v,liste_simp_reel)
+ traiteEntite(v,liste_simp_reel)
+ traiteCache(v)
l.append((v._no,k))
l.sort()
entite.ordre_mc=[ item for index, item in l ]
-def traite_cache(objet):
+def traiteCache(objet):
if not hasattr(objet, "cache"): return
if objet.cache == 0 :return
clef=objet.nom
@@ -72,29 +72,29 @@ def traite_cache(objet):
objet.pere.mcOblig={}
objet.pere.mcOblig[clef]=objet.defaut
-def traite_reel(objet,liste_simp_reel):
+def traiteReel(objet,liste_simp_reel):
if objet.__class__.__name__ == "SIMP":
if ( 'R' in objet.type):
if objet.nom not in liste_simp_reel :
liste_simp_reel.append(objet.nom)
-def analyse_niveau(cata_ordonne_dico,niveau,liste_simp_reel):
+def analyseNiveau(cata_ordonne_dico,niveau,liste_simp_reel):
"""
Analyse un niveau dans un catalogue de commandes
"""
if niveau.l_niveaux == ():
# Il n'y a pas de sous niveaux
for oper in niveau.entites:
- traite_entite(oper,liste_simp_reel)
+ traiteEntite(oper,liste_simp_reel)
cata_ordonne_dico[oper.nom]=oper
else:
for niv in niveau.l_niveaux:
- analyse_niveau(cata_ordonne_dico,niv)
+ analyseNiveau(cata_ordonne_dico,niv)
-def analyse_catalogue(cata):
+def analyseCatalogue(cata):
"""
Cette fonction analyse le catalogue cata pour construire avec l'aide
- de traite_entite la structure de donnees ordre_mc qui donne l'ordre
+ de traiteEntite la structure de donnees ordre_mc qui donne l'ordre
d'apparition des mots cles dans le catalogue
Elle retourne un dictionnaire qui contient toutes les commandes
du catalogue indexees par leur nom
@@ -104,19 +104,19 @@ def analyse_catalogue(cata):
if cata.JdC.l_niveaux == ():
# Il n'y a pas de niveaux
for oper in cata.JdC.commandes:
- traite_entite(oper,liste_simp_reel)
+ traiteEntite(oper,liste_simp_reel)
cata_ordonne_dico[oper.nom]=oper
else:
for niv in cata.JdC.l_niveaux:
- analyse_niveau(cata_ordonne_dico,niv,liste_simp_reel)
+ analyseNiveau(cata_ordonne_dico,niv,liste_simp_reel)
return cata_ordonne_dico,liste_simp_reel
if __name__ == "__main__" :
from Cata import cata_STA6
- dico=analyse_catalogue(cata_STA6)
+ dico=analyseCatalogue(cata_STA6)
#import cata_saturne
- #dico=analyse_catalogue(cata_saturne)
+ #dico=analyseCatalogue(cata_saturne)
def print_entite(entite,dec=' '):
print (dec,entite.nom,entite.__class__.__name__)
diff --git a/Editeur/cata2Xml.py b/Editeur/cata2Xml.py
index 1c5e7e69..e075d18d 100755
--- a/Editeur/cata2Xml.py
+++ b/Editeur/cata2Xml.py
@@ -56,7 +56,7 @@ class CatalogueXML(object):
self.first.append(comment)
self.reglesUtilisees=[]
self.validatorsUtilises=[]
- self.constr_list_txt_cmd()
+ self.constrListTxtCmd()
self.ecrire_fichier()
@@ -70,7 +70,7 @@ class CatalogueXML(object):
except :
print(("Impossible d'ecrire le fichier : "+ str(self.fichier)))
- def constr_list_txt_cmd(self):
+ def constrListTxtCmd(self):
mesCommandes=self.cata.JdC.commandes
self.commandes=ET.SubElement(self.first,'commandes')
for maCommande in mesCommandes:
diff --git a/Editeur/comploader.py b/Editeur/comploader.py
index 9c823dfd..40ba093f 100644
--- a/Editeur/comploader.py
+++ b/Editeur/comploader.py
@@ -23,11 +23,11 @@
- composants : dictionnaire de stockage des relations entre types
d'objet du noyau et types d'item
- - charger_composants() : fonction de chargement des composants. Retourne
+ - chargerComposants() : fonction de chargement des composants. Retourne
le dictionnaire composants.
- gettreeitem(object) -> type d'item : fonction qui retourne un type
d'item correspondant au type de l'objet noyau fourni.
- - make_objecttreeitem(appli,labeltext, object, setfunction=None) -> item : fonction qui retourne un item
+ - makeObjecttreeitem(appli,labeltext, object, setFunction=None) -> item : fonction qui retourne un item
correspondant a l'objet noyau fourni.
"""
# import generaux
@@ -35,22 +35,18 @@ from __future__ import absolute_import
import os,glob,types
# Dictionnaire {object : item} permettant d'associer un item a un object
-# Ce dictionnaire est renseigne par la methode charger_composants
+# Ce dictionnaire est renseigne par la methode chargerComposants
composants = {}
-def charger_composants(Ihm="QT"):
+def chargerComposants(Ihm="QT"):
"""
Cette fonction a pour but de charger tous les modules composants graphiques
(fichiers compo*.py dans le meme repertoire que ce module )
- et de remplir le dictionnaire composants utilise par make_objecttreeitem
+ et de remplir le dictionnaire composants utilise par makeObjecttreeitem
"""
reper=os.path.dirname(__file__)
- if Ihm == "TK" :
- repertoire=reper+"/../InterfaceTK"
- package="InterfaceTK"
- else :
- repertoire=reper+"/../InterfaceQT4"
- package="InterfaceQT4"
+ repertoire=reper+"/../InterfaceQT4"
+ package="InterfaceQT4"
listfich=glob.glob(os.path.join(repertoire, "compo*.py"))
for fichier in listfich:
m= os.path.basename(fichier)[:-3]
@@ -89,12 +85,11 @@ def gettreeitem(object):
itemtype=composants[None]
return itemtype
-def make_objecttreeitem(appli,labeltext, object, setfunction=None):
+def makeObjecttreeitem(appli,labeltext, object, setFunction=None):
"""
Cette fonction permet de construire et de retourner un objet
de type item associe a l'object passe en argument.
"""
c = gettreeitem(object)
- #print appli,labeltext, object, setfunction
- return c(appli,labeltext, object, setfunction)
+ return c(appli,labeltext, object, setFunction)
diff --git a/Editeur/icons/ast-green-dark-ball.png b/Editeur/icons/ast-green-dark-ball.png
new file mode 100644
index 00000000..6fc9d5b5
Binary files /dev/null and b/Editeur/icons/ast-green-dark-ball.png differ
diff --git a/Editeur/listePatrons.py b/Editeur/listePatrons.py
index 074adbc1..f1cf08b4 100644
--- a/Editeur/listePatrons.py
+++ b/Editeur/listePatrons.py
@@ -40,9 +40,9 @@ class listePatrons(object) :
self.sous_menu=sous_menus[code]
self.code=code
self.liste={}
- self.traite_liste()
+ self.traiteListe()
- def traite_liste(self):
+ def traiteListe(self):
if not (self.code in sous_menus) : return
if not (os.path.exists(self.rep_patrons)) : return
for file in os.listdir(self.rep_patrons):
diff --git a/Editeur/session.py b/Editeur/session.py
index 3ff1eb86..14a9df66 100644
--- a/Editeur/session.py
+++ b/Editeur/session.py
@@ -94,7 +94,7 @@ d_env={}
# sont stockees hierarchiquement
#
-def check_comm(option, opt_str, value, parser):
+def checkComm(option, opt_str, value, parser):
if not hasattr(parser.values,"studies"):
parser.values.studies=[]
parser.values.comm=[]
@@ -105,7 +105,7 @@ def check_comm(option, opt_str, value, parser):
parser.values.current=d_study
parser.values.studies.append(d_study)
-def check_poursuite(option, opt_str, value, parser):
+def checkPoursuite(option, opt_str, value, parser):
if parser.values.comm is None:
raise OptionValueError(tr("un fichier de commandes doit etre defini avant une poursuite %s", value))
if not os.path.isfile(value):
@@ -116,7 +116,7 @@ def check_poursuite(option, opt_str, value, parser):
comm["pours"]=d_study
parser.values.current=d_study
-def check_include(option, opt_str, value, parser):
+def checkInclude(option, opt_str, value, parser):
try:
args=[int(parser.rargs[0]),parser.rargs[1]]
except:
@@ -134,7 +134,7 @@ def check_include(option, opt_str, value, parser):
comm[args[0]]=args[1]
-def check_jdc(config,jdc,parser,fich):
+def checkJdc(config,jdc,parser,fich):
"""
Fonction : analyse une section de fichier .ini pour en extraire
les informations sur les fichiers poursuite et includes
@@ -161,7 +161,7 @@ def check_jdc(config,jdc,parser,fich):
de commandes %(v_2)s n'existe pas", \
{'v_1': fich, 'v_2': comm}))
- pours=check_jdc(config,p,parser,fich)
+ pours=checkJdc(config,p,parser,fich)
pours["comm"]=comm
d_study["pours"]=pours
continue
@@ -213,7 +213,7 @@ def check_fich(option, opt_str, fich, parser):
%(v_2)s n'existe pas", {'v_1': fich, 'v_2': comm}))
parser.values.comm.append(comm)
- d_study=check_jdc(config,jdc,parser,fich)
+ d_study=checkJdc(config,jdc,parser,fich)
d_study["comm"]=comm
parser.values.studies.append(d_study)
@@ -234,21 +234,21 @@ def print_d_env():
print((tr("nom etude : %s", study["comm"])))
print_pours(study,dec="++")
-def create_parser():
+def createParser():
# creation du parser des options de la ligne de commande
#import prefs
parser=optparse.OptionParser(usage=tr("utilisation : %prog [options]"), version="%prog 1.13")
parser.add_option(u"-j","--jdc",dest="comm",type='string',
- action="callback",callback=check_comm,
+ action="callback",callback=checkComm,
help=tr("nom du fichier de commandes"))
parser.add_option(u"-p","--poursuite", type="string",dest="pours",
- action="callback", callback=check_poursuite,
+ action="callback", callback=checkPoursuite,
help=tr("nom du fichier poursuite"))
parser.add_option(u"-i","--include",
- action="callback", callback=check_include,
+ action="callback", callback=checkInclude,
nargs=2, help=tr("numero d'unite suivi du nom du fichier include"))
parser.add_option(u"-f","--fich", type="string",dest="fich",
@@ -274,7 +274,7 @@ def create_parser():
return parser
def parse(args):
- parser=create_parser()
+ parser=createParser()
(options,args)=parser.parse_args(args[1:])
if not hasattr(options,"studies"):
options.studies=[]
@@ -306,7 +306,7 @@ def parse(args):
#print_d_env()
return options
-def get_unit(d_study,appli):
+def getUnit(d_study,appli):
"""
Fonction : construit et retourne un dictionnaire contenant les informations
sur les fichiers poursuite et includes sous la forme adaptee
@@ -317,22 +317,22 @@ def get_unit(d_study,appli):
...]
d_study : dictionnaire de l'etude
- appli : objet application EFICAS (permet d'acceder aux services comme get_source)
+ appli : objet application EFICAS (permet d'acceder aux services comme getSource)
"""
- return get_dunit(d_study,appli)
+ return getDunit(d_study,appli)
-def get_dunit(d_unit,appli):
+def getDunit(d_unit,appli):
d={}
if 'pours' in d_unit:
# on a une poursuite
comm=d_unit["pours"]["comm"]
- g=get_dunit(d_unit["pours"],appli)
- text=appli.get_source(comm)
+ g=getDunit(d_unit["pours"],appli)
+ text=appli.getSource(comm)
d[None]=comm,text,g
for k,v in list(d_unit.items()):
if k in (u"pours","comm"): continue
- text=appli.get_source(v)
+ text=appli.getSource(v)
d[k]=v,text,d
return d
diff --git a/Editeur/uiinfo.py b/Editeur/uiinfo.py
index 49e0294f..4e30351f 100644
--- a/Editeur/uiinfo.py
+++ b/Editeur/uiinfo.py
@@ -45,7 +45,7 @@ class UIINFO:
if type(self.groupes) != tuple:
self.groupes=(self.groupes,)
-def traite_commande(commande,niveau):
+def traiteCommande(commande,niveau):
"""
Cette fonction cree l'attribut UI de l'objet commande
a partir des informations contenues dans UIinfo
@@ -63,12 +63,12 @@ def traite_commande(commande,niveau):
if not grp in niveau.dict_groupes: niveau.dict_groupes[grp]=[]
niveau.dict_groupes[grp].append(commande.nom)
-def traite_niveau(niveau):
+def traiteNiveau(niveau):
if niveau.l_niveaux == ():
# Il n'y a pas de sous niveaux. niveau.entites ne contient que des commandes
niveau.dict_groupes={}
for oper in niveau.entites:
- traite_commande(oper,niveau)
+ traiteCommande(oper,niveau)
# A la fin les cles du dictionnaire dict_groupes donnent la liste des groupes
# sans doublon
niveau.liste_groupes=list(niveau.dict_groupes.keys())
@@ -79,7 +79,7 @@ def traite_niveau(niveau):
#print niveau.dict_groupes
else:
for niv in niveau.l_niveaux:
- traite_niveau(niv)
+ traiteNiveau(niv)
def traite_UIinfo(cata):
"""
@@ -95,7 +95,7 @@ def traite_UIinfo(cata):
# dans les attributs liste_groupes et dict_groupes
cata.JdC.dict_groupes={}
for commande in cata.JdC.commandes:
- traite_commande(commande,cata.JdC)
+ traiteCommande(commande,cata.JdC)
# A la fin les cles du dictionnaire dict_groupes donnent la liste des groupes
# sans doublon
cata.JdC.liste_groupes=list(cata.JdC.dict_groupes.keys())
@@ -107,7 +107,7 @@ def traite_UIinfo(cata):
else:
# Le catalogue de commandes contient des definitions de niveau
for niv in cata.JdC.l_niveaux:
- traite_niveau(niv)
+ traiteNiveau(niv)
diff --git a/Extensions/commande_comm.py b/Extensions/commande_comm.py
index 3fb9aebf..96f0bfe1 100644
--- a/Extensions/commande_comm.py
+++ b/Extensions/commande_comm.py
@@ -56,7 +56,7 @@ class COMMANDE_COMM(N_OBJECT.OBJECT,I_OBJECT.OBJECT) :
#self.appel = N_utils.callee_where(niveau=2)
if reg=='oui' : self.register()
- def isvalid(self):
+ def isValid(self):
return 1
def report(self):
@@ -64,7 +64,7 @@ class COMMANDE_COMM(N_OBJECT.OBJECT,I_OBJECT.OBJECT) :
Genere l'objet rapport (classe CR)
"""
self.cr=CR()
- if not self.isvalid(): self.cr.warn(tr("Objet commande commentarise invalide"))
+ if not self.isValid(): self.cr.warn(tr("Objet commande commentarise invalide"))
return self.cr
def copy(self):
@@ -74,18 +74,18 @@ class COMMANDE_COMM(N_OBJECT.OBJECT,I_OBJECT.OBJECT) :
# XXX self.texte ne semble pas exister ???
return COMMANDE_COMM(self.texte,parent = self.parent,reg='non')
- def init_modif(self):
+ def initModif(self):
self.state = 'modified'
- self.parent.init_modif()
+ self.parent.initModif()
- def set_valeur(self,new_valeur):
+ def setValeur(self,new_valeur):
"""
Remplace la valeur de self(si elle existe) par new_valeur)
"""
self.valeur = new_valeur
- self.init_modif()
+ self.initModif()
- def get_valeur(self) :
+ def getValeur(self) :
"""
Retourne la valeur de self, cad le texte de la commande commentarisee
"""
@@ -98,7 +98,7 @@ class COMMANDE_COMM(N_OBJECT.OBJECT,I_OBJECT.OBJECT) :
"""
self.parent.register(self)
- def isoblig(self):
+ def isOblig(self):
"""
Indique si self est obligatoire ou non : retourne toujours 0
"""
@@ -111,13 +111,13 @@ class COMMANDE_COMM(N_OBJECT.OBJECT,I_OBJECT.OBJECT) :
"""
return self.nom
- def isrepetable(self):
+ def isRepetable(self):
"""
Indique si self est repetable ou non : retourne toujours 1
"""
return 1
- def get_attribut(self,nom_attribut) :
+ def getAttribut(self,nom_attribut) :
"""
Retourne l'attribut de nom nom_attribut de self (ou herite)
"""
@@ -126,7 +126,7 @@ class COMMANDE_COMM(N_OBJECT.OBJECT,I_OBJECT.OBJECT) :
else :
return None
- def get_fr(self):
+ def getFr(self):
"""
Retourne l'attribut fr de self.definition
"""
@@ -136,7 +136,7 @@ class COMMANDE_COMM(N_OBJECT.OBJECT,I_OBJECT.OBJECT) :
except:
return ''
- def liste_mc_presents(self):
+ def listeMcPresents(self):
return []
def supprime(self):
@@ -153,26 +153,26 @@ class COMMANDE_COMM(N_OBJECT.OBJECT,I_OBJECT.OBJECT) :
self.val = None
self.appel = None
- def supprime_sdprods(self):
+ def supprimeSdProds(self):
pass
- def update_context(self,d):
+ def updateContext(self,d):
"""
Update le dictionnaire d avec les concepts ou objets produits par self
--> ne fait rien pour une commande en commentaire
"""
pass
- def delete_concept(self,sd):
+ def deleteConcept(self,sd):
pass
- def replace_concept (self,old_sd,sd):
+ def replaceConcept (self,old_sd,sd):
pass
- def get_sdprods(self,nom_sd):
+ def getSdprods(self,nom_sd):
return None
- def uncomment(self):
+ def unComment(self):
"""
Cette methode a pour but de decommentariser l'objet courant,
cad de retourner un tuple contenant :
@@ -180,7 +180,7 @@ class COMMANDE_COMM(N_OBJECT.OBJECT,I_OBJECT.OBJECT) :
- le nom de la sdprod eventuellement produite (sinon None)
"""
# on recupere le contexte avant la commande commentarisee
- context_ini = self.jdc.get_contexte_avant(self)
+ context_ini = self.jdc.getContexte_avant(self)
try:
# on essaie de creer un objet JDC...
CONTEXT.unset_current_step()
@@ -213,12 +213,12 @@ class COMMANDE_COMM(N_OBJECT.OBJECT,I_OBJECT.OBJECT) :
else:
nom_sd = None
#new_etape=new_etape.copy()
- #print "uncomment",new_etape.sd
+ #print "unComment",new_etape.sd
pos=self.parent.etapes.index(self)
- # L'ordre d'appel est important : suppentite fait le menage des concepts dans les etapes suivantes
- self.parent.addentite(new_etape,pos)
- self.parent.suppentite(self)
+ # L'ordre d'appel est important : suppEntite fait le menage des concepts dans les etapes suivantes
+ self.parent.addEntite(new_etape,pos)
+ self.parent.suppEntite(self)
return new_etape,nom_sd
def active(self):
@@ -233,13 +233,13 @@ class COMMANDE_COMM(N_OBJECT.OBJECT,I_OBJECT.OBJECT) :
"""
self.actif = 0
- def isactif(self):
+ def isActif(self):
"""
Booleenne qui retourne 1 si self est valide, 0 sinon
"""
return self.actif
- def verif_condition_bloc(self):
+ def verifConditionBloc(self):
"""
Evalue les conditions de tous les blocs fils possibles
(en fonction du catalogue donc de la definition) de self et
@@ -249,7 +249,7 @@ class COMMANDE_COMM(N_OBJECT.OBJECT,I_OBJECT.OBJECT) :
"""
return [],[]
- def verif_condition_regles(self,liste_presents):
+ def verifConditionRegles(self,liste_presents):
"""
Retourne la liste des mots-cles a rajouter pour satisfaire les regles
en fonction de la liste des mots-cles presents
@@ -261,10 +261,10 @@ class COMMANDE_COMM(N_OBJECT.OBJECT,I_OBJECT.OBJECT) :
Cette methode sert a reinitialiser la parente de l'objet
"""
self.parent=parent
- self.jdc=parent.get_jdc_root()
+ self.jdc=parent.getJdcRoot()
self.etape=self
- def verif_existence_sd(self):
+ def verifExistenceSd(self):
"""
Verifie que les structures de donnees utilisees dans self existent bien dans le contexte
avant etape, sinon enleve la reference a ces concepts
@@ -272,13 +272,13 @@ class COMMANDE_COMM(N_OBJECT.OBJECT,I_OBJECT.OBJECT) :
"""
pass
- def control_sdprods(self,d):
+ def controlSdprods(self,d):
"""sans objet pour les commandes commentarisees"""
pass
def close(self):
pass
- def reset_context(self):
+ def resetContext(self):
pass
diff --git a/Extensions/commentaire.py b/Extensions/commentaire.py
index 22af1192..0ab9b346 100644
--- a/Extensions/commentaire.py
+++ b/Extensions/commentaire.py
@@ -65,18 +65,18 @@ class COMMENTAIRE(N_OBJECT.OBJECT,I_OBJECT.OBJECT) :
c=COMMENTAIRE(valeur=self.valeur,parent=self.jdc)
return c
- def isvalid(self):
+ def isValid(self):
"""
Retourne 1 si self est valide, 0 sinon
Retourne toujours 1 car un commentaire est toujours valide
"""
return 1
- def isoblig(self):
+ def isOblig(self):
""" Indique si self est obligatoire ou non : retourne toujours 0 """
return 0
- def isrepetable(self):
+ def isRepetable(self):
""" Indique si self est repetable ou non : retourne toujours 1 """
return 1
@@ -93,7 +93,7 @@ class COMMENTAIRE(N_OBJECT.OBJECT,I_OBJECT.OBJECT) :
"""
self.actif = 1
- def isactif(self):
+ def isActif(self):
"""
Booleenne qui retourne 1 si self est valide, 0 sinon
"""
@@ -109,32 +109,32 @@ class COMMENTAIRE(N_OBJECT.OBJECT,I_OBJECT.OBJECT) :
self.definition = None
self.niveau = None
- def liste_mc_presents(self):
+ def listeMcPresents(self):
return []
- def get_valeur(self) :
+ def getValeur(self) :
""" Retourne la valeur de self, cad le contenu du commentaire """
try :
return self.valeur
except:
return None
- def set_valeur(self,new_valeur):
+ def setValeur(self,new_valeur):
"""
Remplace la valeur de self(si elle existe) par new_valeur
"""
self.valeur = new_valeur
- self.init_modif()
+ self.initModif()
- def init_modif(self):
+ def initModif(self):
self.state = 'modified'
if self.parent:
- self.parent.init_modif()
+ self.parent.initModif()
- def supprime_sdprods(self):
+ def supprimeSdProds(self):
pass
- def update_context(self,d):
+ def updateContext(self,d):
"""
Update le dictionnaire d avec les concepts ou objets produits par self
--> ne fait rien pour un commentaire
@@ -144,7 +144,7 @@ class COMMENTAIRE(N_OBJECT.OBJECT,I_OBJECT.OBJECT) :
def report(self):
""" Genere l'objet rapport (classe CR) """
self.cr=CR()
- if not self.isvalid(): self.cr.warn(tr("Objet commentaire non valorise"))
+ if not self.isValid(): self.cr.warn(tr("Objet commentaire non valorise"))
return self.cr
def ident(self):
@@ -153,13 +153,13 @@ class COMMENTAIRE(N_OBJECT.OBJECT,I_OBJECT.OBJECT) :
"""
return self.nom
- def delete_concept(self,sd):
+ def deleteConcept(self,sd):
pass
- def replace_concept (self,old_sd,sd):
+ def replaceConcept (self,old_sd,sd):
pass
- def verif_condition_bloc(self):
+ def verifConditionBloc(self):
"""
Evalue les conditions de tous les blocs fils possibles
(en fonction du catalogue donc de la definition) de self et
@@ -169,36 +169,36 @@ class COMMENTAIRE(N_OBJECT.OBJECT,I_OBJECT.OBJECT) :
"""
return [],[]
- def verif_condition_regles(self,liste_presents):
+ def verifConditionRegles(self,liste_presents):
"""
Retourne la liste des mots-cles a rajouter pour satisfaire les regles
en fonction de la liste des mots-cles presents
"""
return []
- def get_sdprods(self,nom_sd):
+ def getSdprods(self,nom_sd):
"""
Retourne les concepts produits par la commande
"""
return None
- def verif_existence_sd(self):
+ def verifExistenceSd(self):
pass
- def get_fr(self):
+ def getFr(self):
"""
Retourne le commentaire lui meme tronque a la 1ere ligne
"""
return self.valeur.split('\n',1)[0]
- def control_sdprods(self,d):
+ def controlSdprods(self,d):
"""sans objet """
pass
def close(self):
pass
- def reset_context(self):
+ def resetContext(self):
pass
diff --git a/Extensions/etape_niveau.py b/Extensions/etape_niveau.py
index 57a9fbd7..0e1c47c6 100644
--- a/Extensions/etape_niveau.py
+++ b/Extensions/etape_niveau.py
@@ -30,7 +30,7 @@ class ETAPE_NIVEAU(N_OBJECT.OBJECT):
def __init__(self,niveau,parent):
self.parent = parent
- self.jdc = self.parent.get_jdc_root()
+ self.jdc = self.parent.getJdcRoot()
self.niveau = self
self.definition = niveau
self.etapes=[]
@@ -38,9 +38,9 @@ class ETAPE_NIVEAU(N_OBJECT.OBJECT):
self.dict_niveaux={}
self.editmode = 0
self.state="undetermined"
- self.build_niveaux()
+ self.buildNiveaux()
- def build_niveaux(self):
+ def buildNiveaux(self):
for niveau in self.definition.l_niveaux:
etape_niveau = ETAPE_NIVEAU(niveau,self)
self.etapes_niveaux.append(etape_niveau)
@@ -52,7 +52,7 @@ class ETAPE_NIVEAU(N_OBJECT.OBJECT):
- si editmode = 0 : on est en mode relecture d'un fichier de commandes
auquel cas on ajoute etape a la fin de la liste self.etapes
- si editmode = 1 : on est en mode ajout d'etape depuis eficas auquel cas
- cette methode ne fait rien, c'est addentite qui enregistre etape
+ cette methode ne fait rien, c'est addEntite qui enregistre etape
a la bonne place dans self.etapes
"""
if self.editmode : return
@@ -67,14 +67,14 @@ class ETAPE_NIVEAU(N_OBJECT.OBJECT):
def ident(self):
return self.definition.label
- def isactif(self):
+ def isActif(self):
#print 'Niveau : ',self.definition.nom
#print '\tactif =',self.definition.actif
if self.definition.actif == 1 :
return 1
else :
# self.actif est une condition a evaluer dans un certain contexte ...
- d = self.cree_dict_valeurs()
+ d = self.creeDictValeurs()
try:
t=eval(self.definition.actif,d)
return t
@@ -82,39 +82,39 @@ class ETAPE_NIVEAU(N_OBJECT.OBJECT):
traceback.print_exc()
return 0
- def cree_dict_valeurs(self):
+ def creeDictValeurs(self):
"""
Retourne le dictionnaire des freres aines de self compose des couples :
- {nom_frere isvalid()}
+ {nom_frere isValid()}
"""
d={}
for niveau in self.parent.etapes_niveaux:
if niveau is self : break
- d[niveau.definition.nom]=niveau.isvalid()
+ d[niveau.definition.nom]=niveau.isValid()
return d
- def isvalid(self):
+ def isValid(self):
""" Methode booleenne qui retourne 0 si le niveau est invalide, 1 sinon """
if self.etapes_niveaux == []:
if len(self.etapes) == 0:
return self.definition.valide_vide
else:
for etape in self.etapes :
- if not etape.isvalid() : return 0
+ if not etape.isValid() : return 0
return 1
else:
for etape_niveau in self.etapes_niveaux :
- if not etape_niveau.isvalid() : return 0
+ if not etape_niveau.isValid() : return 0
return 1
def accept(self,visitor):
visitor.visitETAPE_NIVEAU(self)
- def addentite(self,name,pos_rel):
+ def addEntite(self,name,pos_rel):
self.editmode = 1
try :
pos_abs=self.jdc.get_nb_etapes_avant(self)+pos_rel
- cmd = self.jdc.addentite(name,pos_abs)
+ cmd = self.jdc.addEntite(name,pos_abs)
self.etapes.insert(pos_rel,cmd)
self.editmode = 0
return cmd
@@ -123,14 +123,14 @@ class ETAPE_NIVEAU(N_OBJECT.OBJECT):
self.editmode = 0
return None
- def suppentite(self,etape) :
+ def suppEntite(self,etape) :
""" Classe ETAPE_NIVEAU
Supprime une etape
"""
- self.jdc.suppentite(etape)
+ self.jdc.suppEntite(etape)
- def get_fr(self):
+ def getFr(self):
"""
Retourne le texte d'aide dans la langue choisie
"""
diff --git a/Extensions/interpreteur_formule.py b/Extensions/interpreteur_formule.py
index 16d0b442..14965cd3 100644
--- a/Extensions/interpreteur_formule.py
+++ b/Extensions/interpreteur_formule.py
@@ -107,11 +107,11 @@ class Interpreteur_Formule(object):
if type(formule) != types.tuple:
raise InterpreteurException(tr("La formule passee a l'interpreteur doit etre sous forme de tuple"))
self.t_formule = formule
- #self.init_cr()
- self.modify_listes()
- self.ordonne_listes()
+ #self.initCr()
+ self.modifyListes()
+ self.ordonneListes()
- def init_cr(self):
+ def initCr(self):
"""
Initialise le cr,cad valorise les chaines debut et fin
"""
@@ -149,18 +149,18 @@ class Interpreteur_Formule(object):
self.l_children.append(fils)
self.cr.add(fils.cr)
- def isvalid(self):
+ def isValid(self):
"""
Booleenne qui retourne 1 si la formule est valide, 0 sinon
Methode externe
"""
self.l_operateurs = []
self.cr.purge() # on vide le cr
- self.init_cr() # on initialise le cr
- self.interprete_formule()
+ self.initCr() # on initialise le cr
+ self.interpreteFormule()
return self.cr.estvide()
- def interprete_formule(self):
+ def interpreteFormule(self):
"""
Realise l'interpretation du corps de la formule
"""
@@ -173,11 +173,11 @@ class Interpreteur_Formule(object):
# Enleve les espaces
text_arg = text_arg.replace(' ','')
try:
- self.l_operateurs.append(self.split_operateurs(text_arg))
+ self.l_operateurs.append(self.splitOperateurs(text_arg))
except InterpreteurException as e:
self.cr.fatal(e.__str__())
- def modify_listes(self):
+ def modifyListes(self):
"""
Modifie la liste des constantes en lui ajoutant le nom des parametres
de la fonction a interpreter
@@ -202,11 +202,11 @@ class Interpreteur_Formule(object):
self.l_constantes.append(cte)
# on ajoute les fonctions unaires externes au dictionnaire des fonctions unaires
for new_fonc in self.new_fonctions_unaires:
- self.d_fonctions_unaires[new_fonc[0]] = self.get_nb_args(new_fonc)
+ self.d_fonctions_unaires[new_fonc[0]] = self.getNbArgs(new_fonc)
#self.d_fonctions_unaires.update(self.new_fonctions_unaires)
self.l_fonctions_unaires = list(self.d_fonctions_unaires.keys())
- def ordonne_listes(self):
+ def ordonneListes(self):
"""
Ordonne les listes de fonctions unaires et binaires
"""
@@ -215,7 +215,7 @@ class Interpreteur_Formule(object):
self.l_constantes.sort(cmp_function)
- def split_operateurs(self,texte):
+ def splitOperateurs(self,texte):
"""
Splite le texte passe en argument en operateurs plus elementaires.
N'analyse pas l'interieur des operateurs (ne fait qu'une passe)
@@ -224,29 +224,29 @@ class Interpreteur_Formule(object):
texte = texte.strip()
# on recherche un nombre en debut de texte
try:
- oper,reste = self.cherche_nombre(texte)
+ oper,reste = self.chercheNombre(texte)
except InterpreteurException as e:
raise InterpreteurException (e.__str__())
if not oper :
# on recherche une constante en debut de texte
try:
- oper,reste = self.cherche_constante(texte)
+ oper,reste = self.chercheConstante(texte)
except InterpreteurException as e:
raise InterpreteurException (e.__str__())
if not oper :
# on recherche une expression entre parentheses...
try:
- oper,reste = self.cherche_expression_entre_parentheses(texte)
+ oper,reste = self.chercheExpressionEntreParentheses(texte)
except InterpreteurException as e:
raise InterpreteurException(e.__str__())
if not oper :
# on recherche le debut d'un operateur unaire en debut de texte
try:
- oper,reste = self.cherche_operateur_unaire(texte)
+ oper,reste = self.chercheOperateurUnaire(texte)
except InterpreteurException as e:
raise InterpreteurException(e.__str__())
if not oper :
- type_objet,nom_objet = self.get_type(texte)
+ type_objet,nom_objet = self.getType(texte)
if type_objet == 'constante':
raise InterpreteurException( "Constante %s inconnue" %nom_objet)
elif type_objet == 'fonction':
@@ -259,16 +259,16 @@ class Interpreteur_Formule(object):
l_operateurs.append(oper)
if reste :
texte = reste.strip()
- oper,reste = self.cherche_operateur_binaire(texte)
+ oper,reste = self.chercheOperateurBinaire(texte)
if not oper :
# on a un reste et pas d'operateur binaire --> erreur
raise InterpreteurException("L'operateur %s doit etre suivi d'un operateur binaire" %l_operateurs[-1])
else:
# on a bien trouve un operateur binaire:
l_operateurs.append(oper)
- # il faut recommencer l'analyse du reste par split_operateurs ...
+ # il faut recommencer l'analyse du reste par splitOperateurs ...
try:
- l_op = self.split_operateurs(reste)
+ l_op = self.splitOperateurs(reste)
except InterpreteurException as e:
raise InterpreteurException(e.__str__())
l_operateurs.extend(l_op)
@@ -277,7 +277,7 @@ class Interpreteur_Formule(object):
# on a fini d'analyser texte
return l_operateurs
- def cherche_nombre(self,texte):
+ def chercheNombre(self,texte):
"""
Cherche un nombre en debut de texte
Retourne ce nombre et le reste ou None et le texte initial
@@ -318,7 +318,7 @@ class Interpreteur_Formule(object):
# on n'a pas trouve de nombre
return None,texte
- def cherche_constante_old(self,texte):
+ def chercheConstanteOld(self,texte):
"""
Recherche une constante en debut de texte parmi la liste des constantes.
Retourne le texte representant la constante et le reste du texte ou
@@ -339,7 +339,7 @@ class Interpreteur_Formule(object):
# aucune constante trouvee
return None,texte
- def cherche_constante(self,texte):
+ def chercheConstante(self,texte):
"""
Recherche une constante en debut de texte parmi la liste des constantes.
Retourne le texte representant la constante et le reste du texte ou
@@ -368,7 +368,7 @@ class Interpreteur_Formule(object):
# aucune constante trouvee
return None,texte
- def cherche_args(self,texte):
+ def chercheArgs(self,texte):
"""
Cherche au debut de texte une liste d'arguments entre parentheses
"""
@@ -392,7 +392,7 @@ class Interpreteur_Formule(object):
# on a fini d'analyser le texte : reste = None
return texte,None
- def cherche_operateur_unaire_old(self,texte):
+ def chercheOperateurUnaireOld(self,texte):
"""
Cherche dans texte un operateur unaire
"""
@@ -409,7 +409,7 @@ class Interpreteur_Formule(object):
operateur = txt
texte = reste
try:
- args,reste = self.cherche_args(texte)
+ args,reste = self.chercheArgs(texte)
except InterpreteurException as e:
raise InterpreteurException(e.__str__())
if not args :
@@ -417,20 +417,20 @@ class Interpreteur_Formule(object):
raise InterpreteurException('operateur unaire %s sans arguments' %operateur)
else:
#operateur = operateur+args
- args = self.split_args(txt,args,self.d_fonctions_unaires[operateur])
+ args = self.splitArgs(txt,args,self.d_fonctions_unaires[operateur])
formule_operateur = (txt,'',self.t_formule[2],args)
operateur = Interpreteur_Formule(formule = formule_operateur,
constantes = self.new_constantes,
fonctions_unaires = self.new_fonctions_unaires,
parent = self)
- operateur.interprete_formule()
+ operateur.interpreteFormule()
texte = reste
return operateur,reste
else:
# aucun operateur unaire trouve
return None,texte
- def cherche_operateur_unaire(self,texte):
+ def chercheOperateurUnaire(self,texte):
"""
Cherche dans texte un operateur unaire
"""
@@ -445,30 +445,30 @@ class Interpreteur_Formule(object):
identificateur = l_groups[1].strip()
reste = l_groups[2]
try:
- args,reste = self.cherche_args(reste)
+ args,reste = self.chercheArgs(reste)
except InterpreteurException as e:
raise InterpreteurException (e.__str__())
if not args :
# operateur unaire sans arguments
- # en principe on ne doit jamais etre dans ce cas car il est deja trappe par cherche_constante ...
+ # en principe on ne doit jamais etre dans ce cas car il est deja trappe par chercheConstante ...
raise InterpreteurException ('Fonction %s sans arguments !' %identificateur)
else:
# il faut encore verifier que l'on a bien a faire a une fonction connue
if identificateur not in self.l_fonctions_unaires:
raise InterpreteurException ('Fonction %s inconnue dans %s !' %(identificateur,texte))
- args = self.split_args(identificateur,args,self.d_fonctions_unaires[identificateur])
+ args = self.splitArgs(identificateur,args,self.d_fonctions_unaires[identificateur])
formule_operateur = (sgn+identificateur,'',self.t_formule[2],args)
operateur = Interpreteur_Formule(formule = formule_operateur,
constantes = self.new_constantes,
fonctions = self.new_fonctions_unaires,
parent = self)
- operateur.interprete_formule()
+ operateur.interpreteFormule()
texte = reste
return operateur,reste
elif texte[0] == '-':
# Il faut pouvoir trapper les expressions du type exp(-(x+1)) ...
try :
- args,reste = self.cherche_args(texte[1:])
+ args,reste = self.chercheArgs(texte[1:])
except InterpreteurException as e:
raise InterpreteurException (e.__str__())
if not args :
@@ -476,19 +476,19 @@ class Interpreteur_Formule(object):
return None,texte
else:
identificateur = '-'
- args = self.split_args(identificateur,args,self.d_fonctions_unaires[identificateur])
+ args = self.splitArgs(identificateur,args,self.d_fonctions_unaires[identificateur])
formule_operateur = (identificateur,'',self.t_formule[2],args)
operateur = Interpreteur_Formule(formule = formule_operateur,
constantes = self.new_constantes,
fonctions = self.new_fonctions_unaires,
parent = self)
- operateur.interprete_formule()
+ operateur.interpreteFormule()
texte = reste
return operateur,reste
else:
return None,texte
- def cherche_operateur_binaire(self,texte):
+ def chercheOperateurBinaire(self,texte):
"""
Cherche dans texte un operateur unaire
"""
@@ -507,11 +507,11 @@ class Interpreteur_Formule(object):
# aucun operateur unaire trouve
return None,texte
- def cherche_expression_entre_parentheses(self,texte):
+ def chercheExpressionEntreParentheses(self,texte):
"""
Cherche en debut de texte une expression entre parentheses
"""
- args,reste = self.cherche_args(texte.strip())
+ args,reste = self.chercheArgs(texte.strip())
if not args :
return None,texte
else:
@@ -522,11 +522,11 @@ class Interpreteur_Formule(object):
constantes = self.new_constantes,
fonctions = self.new_fonctions_unaires,
parent = self)
- operateur.interprete_formule()
+ operateur.interpreteFormule()
texte = reste
return operateur,reste
- def split_args(self,nom_fonction,args,nb_args):
+ def splitArgs(self,nom_fonction,args,nb_args):
"""
Tente de partager args en nb_args elements
Retourne une liste de chaines de caracteres (liste de longueur nb_args)
@@ -539,7 +539,7 @@ class Interpreteur_Formule(object):
else:
return l_args
- def get_type(self,texte):
+ def getType(self,texte):
"""
Retourne le type de l'objet defini dans texte, a savoir:
- constante
@@ -555,7 +555,7 @@ class Interpreteur_Formule(object):
nom_oper,args = texte.split('(',1)
return 'fonction',nom_oper
- def get_nb_args(self,formule):
+ def getNbArgs(self,formule):
"""
Retourne le nombre d'arguments dans la definition de formule (sous forme de tuple)
"""
@@ -582,7 +582,7 @@ if __name__ == '__main__':
fonctions = fonctions_unaires)
txt = i.str()
print(('\nformule %s = %s' %(str(formule),txt)))
- #if i.isvalid() :
+ #if i.isValid() :
# print "\n\tPas d'erreur !"
#else:
# print i.report()
diff --git a/Extensions/jdc.py b/Extensions/jdc.py
index 41df571e..e984c864 100644
--- a/Extensions/jdc.py
+++ b/Extensions/jdc.py
@@ -31,9 +31,9 @@ from . import etape_niveau
class JDC(object):
def __init__(self):
self.dict_niveaux={}
- self.build_niveaux()
+ self.buildNiveaux()
- def build_niveaux(self):
+ def buildNiveaux(self):
for niveau in self.definition.l_niveaux:
etape_niv = etape_niveau.ETAPE_NIVEAU(niveau,self)
self.etapes_niveaux.append(etape_niv)
diff --git a/Extensions/jdc_include.py b/Extensions/jdc_include.py
index fff0ab9c..6d5bb7f9 100644
--- a/Extensions/jdc_include.py
+++ b/Extensions/jdc_include.py
@@ -96,11 +96,11 @@ class JDC_POURSUITE(JDC):
# On pourrait verifier que le jdc_pere apres l'etape etape_include
# ne contient pas deja un concept de ce nom
- #if self.jdc_pere.get_sd_apres_etape_avec_detruire(sdnom,etape=self.etape_include):
+ #if self.jdc_pere.getSdApresEtapeAvecDetruire(sdnom,etape=self.etape_include):
# Il existe un concept apres self => impossible d'inserer
# raise AsException("Nom de concept deja defini : %s" % sdnom)
# On a choisi de ne pas faire ce test ici mais de le faire en bloc
- # si necessaire apres en appelant la methode verif_contexte
+ # si necessaire apres en appelant la methode verifContexte
# ATTENTION : Il ne faut pas ajouter sd dans sds car il s y trouve deja.
# Ajoute a la creation (appel de reg_sd).
@@ -111,16 +111,16 @@ class JDC_POURSUITE(JDC):
if restrict == 'non':
self.g_context[sdnom]=sd
- def get_verif_contexte(self):
- #print "get_verif_contexte"
- j_context=self.get_contexte_avant(None)
- self.verif_contexte(j_context)
+ def getVerifContexte(self):
+ #print "getVerifContexte"
+ j_context=self.getContexte_avant(None)
+ self.verifContexte(j_context)
return j_context
- def force_contexte(self,contexte):
+ def forceContexte(self,contexte):
for nom_sd,sd in list(contexte.items()):
if not isinstance(sd,ASSD):continue
- autre_sd= self.jdc_pere.get_sd_apres_etape_avec_detruire(nom_sd,sd,
+ autre_sd= self.jdc_pere.getSdApresEtapeAvecDetruire(nom_sd,sd,
etape=self.etape_include)
if autre_sd is None:continue
if sd is not autre_sd:
@@ -131,7 +131,7 @@ class JDC_POURSUITE(JDC):
return contexte
- def verif_contexte(self,context):
+ def verifContexte(self,context):
"""
Cette methode verifie si le contexte passe en argument (context)
peut etre insere dans le jdc pere de l'include.
@@ -141,10 +141,10 @@ class JDC_POURSUITE(JDC):
Si le contexte ne peut pas etre insere, la methode leve une
exception sinon elle retourne le contexte inchange
"""
- #print "verif_contexte"
+ #print "verifContexte"
for nom_sd,sd in list(context.items()):
if not isinstance(sd,ASSD):continue
- autre_sd= self.jdc_pere.get_sd_apres_etape_avec_detruire(nom_sd,sd,
+ autre_sd= self.jdc_pere.getSdApresEtapeAvecDetruire(nom_sd,sd,
etape=self.etape_include)
if autre_sd is None:continue
if sd is not autre_sd:
@@ -155,13 +155,13 @@ class JDC_POURSUITE(JDC):
return context
- def get_liste_cmd(self):
+ def getListeCmd(self):
"""
Retourne la liste des commandes du catalogue
"""
if self.jdc_pere is None:
- return JDC.get_liste_cmd(self)
- return self.jdc_pere.get_liste_cmd()
+ return JDC.getListeCmd(self)
+ return self.jdc_pere.getListeCmd()
def get_groups(self):
"""
@@ -171,20 +171,20 @@ class JDC_POURSUITE(JDC):
return JDC.get_groups(self)
return self.jdc_pere.get_groups()
- def init_modif(self):
+ def initModif(self):
"""
Met l'etat de l'etape a : modifie
Propage la modification au parent
- Attention : init_modif doit etre appele avant de realiser une modification
+ Attention : initModif doit etre appele avant de realiser une modification
La validite devra etre recalculee apres cette modification
mais par un appel a fin_modif pour preserver l'etat modified
de tous les objets entre temps
"""
- #print "jdc_include.init_modif",self,self.etape_include
+ #print "jdc_include.initModif",self,self.etape_include
self.state = 'modified'
if self.etape_include:
- self.etape_include.init_modif()
+ self.etape_include.initModif()
def fin_modif(self):
"""
@@ -214,7 +214,7 @@ class JDC_POURSUITE(JDC):
# self.context_ini={}
# self.procedure=None
- def get_contexte_avant(self,etape):
+ def getContexte_avant(self,etape):
"""
Retourne le dictionnaire des concepts connus avant etape
On tient compte des concepts produits par le jdc pere
@@ -223,33 +223,33 @@ class JDC_POURSUITE(JDC):
comme DETRUIRE ou les macros
Si etape == None, on retourne le contexte en fin de JDC
"""
- #print "jdc_include.get_contexte_avant",etape,etape and etape.nom
+ #print "jdc_include.getContexte_avant",etape,etape and etape.nom
if self.etape_include:
- new_context=self.etape_include.parent.get_contexte_avant(self.etape_include).copy()
+ new_context=self.etape_include.parent.getContexte_avant(self.etape_include).copy()
self.context_ini=new_context
- d= JDC.get_contexte_avant(self,etape)
+ d= JDC.getContexte_avant(self,etape)
return d
- def reset_context(self):
- #print "jdc_include.reset_context",self,self.nom
+ def resetContext(self):
+ #print "jdc_include.resetContext",self,self.nom
if self.etape_include:
- self.etape_include.parent.reset_context()
- new_context=self.etape_include.parent.get_contexte_avant(self.etape_include).copy()
+ self.etape_include.parent.resetContext()
+ new_context=self.etape_include.parent.getContexte_avant(self.etape_include).copy()
self.context_ini=new_context
- JDC.reset_context(self)
+ JDC.resetContext(self)
- def get_sd_apres_etape(self,nom_sd,etape,avec='non'):
+ def getSdApresEtape(self,nom_sd,etape,avec='non'):
"""
Cette methode retourne la SD de nom nom_sd qui est eventuellement
definie apres etape
Si avec vaut 'non' exclut etape de la recherche
"""
if self.etape_include:
- sd=self.etape_include.parent.get_sd_apres_etape(nom_sd,self.etape_include,'non')
+ sd=self.etape_include.parent.getSdApresEtape(nom_sd,self.etape_include,'non')
if sd:return sd
- return JDC.get_sd_apres_etape(self,nom_sd,etape,avec)
+ return JDC.getSdApresEtape(self,nom_sd,etape,avec)
- def get_sd_apres_etape_avec_detruire(self,nom_sd,sd,etape,avec='non'):
+ def getSdApresEtapeAvecDetruire(self,nom_sd,sd,etape,avec='non'):
"""
On veut savoir ce que devient le concept sd de nom nom_sd apres etape.
Il peut etre detruit, remplace ou conserve
@@ -257,17 +257,17 @@ class JDC_POURSUITE(JDC):
definie apres etape en tenant compte des concepts detruits
Si avec vaut 'non' exclut etape de la recherche
"""
- #print "jdc_include.get_sd_apres_etape_avec_detruire",nom_sd,sd,id(sd)
- autre_sd=JDC.get_sd_apres_etape_avec_detruire(self,nom_sd,sd,etape,avec)
+ #print "jdc_include.getSdApresEtapeAvecDetruire",nom_sd,sd,id(sd)
+ autre_sd=JDC.getSdApresEtapeAvecDetruire(self,nom_sd,sd,etape,avec)
# si autre_sd vaut None le concept sd a ete detruit. On peut terminer
# la recherche en retournant None
# Si autre_sd ne vaut pas sd, le concept a ete redefini. On peut terminer
# la recherche en retournant le concept nouvellement defini
# Sinon, on poursuit la recherche dans les etapes du niveau superieur.
if autre_sd is None or autre_sd is not sd :return autre_sd
- return self.etape_include.parent.get_sd_apres_etape_avec_detruire(nom_sd,sd,self.etape_include,'non')
+ return self.etape_include.parent.getSdApresEtapeAvecDetruire(nom_sd,sd,self.etape_include,'non')
- def delete_concept(self,sd):
+ def deleteConcept(self,sd):
"""
Fonction : Mettre a jour les etapes du JDC suite a la disparition du
concept sd
@@ -275,48 +275,48 @@ class JDC_POURSUITE(JDC):
que de transmettre aux fils
"""
# Nettoyage des etapes de l'include
- JDC.delete_concept(self,sd)
+ JDC.deleteConcept(self,sd)
# Nettoyage des etapes du parent
if self.etape_include:
- self.etape_include.parent.delete_concept_after_etape(self.etape_include,sd)
+ self.etape_include.parent.deleteConceptAfterEtape(self.etape_include,sd)
- def delete_concept_after_etape(self,etape,sd):
+ def deleteConceptAfterEtape(self,etape,sd):
"""
Fonction : Mettre a jour les etapes du JDC qui sont apres etape suite a
la disparition du concept sd
"""
# Nettoyage des etapes de l'include
- JDC.delete_concept_after_etape(self,etape,sd)
+ JDC.deleteConceptAfterEtape(self,etape,sd)
# Nettoyage des etapes du parent
if self.etape_include:
- self.etape_include.parent.delete_concept_after_etape(self.etape_include,sd)
+ self.etape_include.parent.deleteConceptAfterEtape(self.etape_include,sd)
- def update_concept_after_etape(self,etape,sd):
+ def updateConceptAfterEtape(self,etape,sd):
"""
Fonction : mettre a jour les etapes du JDC suite a une modification
du concept sd (principalement renommage)
"""
- JDC.update_concept_after_etape(self,etape,sd)
+ JDC.updateConceptAfterEtape(self,etape,sd)
if self.etape_include:
- self.etape_include.parent.update_concept_after_etape(self.etape_include,sd)
+ self.etape_include.parent.updateConceptAfterEtape(self.etape_include,sd)
- def replace_concept_after_etape(self,etape,old_sd,sd):
+ def replaceConceptAfterEtape(self,etape,old_sd,sd):
"""
Fonction : Mettre a jour les etapes du JDC qui sont apres etape suite au
remplacement du concept old_sd par sd
"""
# Nettoyage des etapes de l'include
- JDC.replace_concept_after_etape(self,etape,old_sd,sd)
+ JDC.replaceConceptAfterEtape(self,etape,old_sd,sd)
# Nettoyage des etapes du parent
if self.etape_include:
- self.etape_include.parent.replace_concept_after_etape(self.etape_include,old_sd,sd)
+ self.etape_include.parent.replaceConceptAfterEtape(self.etape_include,old_sd,sd)
def changefichier(self,fichier):
if self.etape_include:
self.etape_include.fichier_ini=fichier
self.fin_modif()
- def control_context_apres(self,etape):
+ def controlContextApres(self,etape):
"""
Cette methode verifie que les etapes apres l'etape etape
ont bien des concepts produits acceptables (pas de conflit de
@@ -325,24 +325,24 @@ class JDC_POURSUITE(JDC):
Effectue les verifications sur les etapes du jdc mais aussi sur les
jdc parents s'ils existent.
"""
- #print "jdc_include.control_context_apres",self,etape
+ #print "jdc_include.controlContextApres",self,etape
#Regularise les etapes du jdc apres l'etape etape
self.control_jdc_context_apres(etape)
if self.etape_include:
#print "CONTROL_INCLUDE:",self.etape_include,self.etape_include.nom
# il existe un jdc pere. On propage la regularisation
- self.etape_include.parent.control_context_apres(self.etape_include)
+ self.etape_include.parent.controlContextApres(self.etape_include)
class JDC_INCLUDE(JDC_POURSUITE):
- def get_liste_cmd(self):
+ def getListeCmd(self):
"""
Retourne la liste des commandes du catalogue
"""
if self.jdc_pere is None:
- return JDC.get_liste_cmd(self)
- return [e for e in self.jdc_pere.get_liste_cmd() if e not in ("DEBUT","POURSUITE","FIN") ]
+ return JDC.getListeCmd(self)
+ return [e for e in self.jdc_pere.getListeCmd() if e not in ("DEBUT","POURSUITE","FIN") ]
- def active_etapes(self):
+ def activeEtapes(self):
for e in self.etapes:
e.active()
diff --git a/Extensions/mcnuplet.py b/Extensions/mcnuplet.py
index ace02b6a..8a61173c 100644
--- a/Extensions/mcnuplet.py
+++ b/Extensions/mcnuplet.py
@@ -86,7 +86,7 @@ class MCNUPLET(V_MCCOMPO.MCCOMPO,N_MCCOMPO.MCCOMPO):
self.reste_val={}
return mc_liste
- def isvalid(self,cr='non'):
+ def isValid(self,cr='non'):
"""
Indique si self (MCNUPLET) est un objet valide ou non : retourne 1 si oui, 0 sinon
"""
@@ -99,7 +99,7 @@ class MCNUPLET(V_MCCOMPO.MCCOMPO,N_MCCOMPO.MCCOMPO):
else:
old_valid = None
for child in self.mc_liste :
- if not child.isvalid():
+ if not child.isValid():
valid = 0
break
if len(self.mc_liste) != len(self.definition.entites):
@@ -109,7 +109,7 @@ class MCNUPLET(V_MCCOMPO.MCCOMPO,N_MCCOMPO.MCCOMPO):
self.valid = valid
self.state = 'unchanged'
if old_valid:
- if old_valid != self.valid : self.init_modif_up()
+ if old_valid != self.valid : self.initModifUp()
return self.valid
def __getitem__(self,key):
@@ -140,13 +140,13 @@ class MCNUPLET(V_MCCOMPO.MCCOMPO,N_MCCOMPO.MCCOMPO):
s=s + str(e.valeur) + ','
return s + ')'
- def get_regles(self):
+ def getRegles(self):
"""
Retourne la liste des regles attachees au nuplet
"""
return []
- def verif_condition_bloc(self):
+ def verifConditionBloc(self):
"""
Verifie s'il y a des blocs sous le nuplet et retourne
les blocs en question
@@ -154,7 +154,7 @@ class MCNUPLET(V_MCCOMPO.MCCOMPO,N_MCCOMPO.MCCOMPO):
# Il n y a pas de BLOCs sous un NUPLET
return [],[]
- def isrepetable(self):
+ def isRepetable(self):
"""
Indique si le NUPLET peut etre repete.
Retourne 1 si c'est le cas.
@@ -169,10 +169,10 @@ class MCNUPLET(V_MCCOMPO.MCCOMPO,N_MCCOMPO.MCCOMPO):
def makeobjet(self):
return self.definition(val = None, nom = self.nom,parent = self.parent)
- def get_valeur(self):
+ def getValeur(self):
"""
Cette methode doit retourner la valeur de l'objet. Elle est utilisee par
- cree_dict_valeurs pour construire un dictionnaire contenant les mots cles
+ creeDictValeurs pour construire un dictionnaire contenant les mots cles
d'une etape.
Dans le cas d'un nuplet, on retournera comme valeur une liste des valeurs
des mots cle simples contenus.
@@ -182,7 +182,7 @@ class MCNUPLET(V_MCCOMPO.MCCOMPO,N_MCCOMPO.MCCOMPO):
l.append(v.valeur)
return l
- def get_val(self):
+ def getVal(self):
"""
Une autre methode qui retourne une "autre" valeur du mot cle facteur.
Elle est utilisee par la methode get_mocle
@@ -192,10 +192,10 @@ class MCNUPLET(V_MCCOMPO.MCCOMPO,N_MCCOMPO.MCCOMPO):
l.append(v.valeur)
return l
- def isoblig(self):
+ def isOblig(self):
return self.definition.statut=='o'
- def get_fr(self):
+ def getFr(self):
"""
Retourne le texte d'aide dans la langue choisie
"""
@@ -204,11 +204,11 @@ class MCNUPLET(V_MCCOMPO.MCCOMPO,N_MCCOMPO.MCCOMPO):
except:
return ''
- def cree_dict_valeurs(self,liste=[],condition=0):
+ def creeDictValeurs(self,liste=[],condition=0):
dico={}
return dico
- def update_condition_bloc(self):
+ def updateConditionBloc(self):
"""
Realise l'update des blocs conditionnels fils de self
et propage au parent (rien a faire pour nuplet)
diff --git a/Extensions/niveau.py b/Extensions/niveau.py
index 6cb97901..9ca012e9 100644
--- a/Extensions/niveau.py
+++ b/Extensions/niveau.py
@@ -47,7 +47,7 @@ class NIVEAU(object):
self.entites.append(commande)
self.l_noms_entites.append(commande.nom)
- def get_liste_cmd(self):
+ def getListeCmd(self):
self.l_noms_entites.sort()
return self.l_noms_entites
diff --git a/Extensions/parametre.py b/Extensions/parametre.py
index 1e29fd53..44094951 100644
--- a/Extensions/parametre.py
+++ b/Extensions/parametre.py
@@ -70,12 +70,12 @@ class PARAMETRE(N_OBJECT.OBJECT,I_OBJECT.OBJECT,Formula) :
self.state='undetermined'
self.register()
self.dict_valeur=[]
- #self.valeur = self.interprete_valeur(valeur)
+ #self.valeur = self.interpreteValeur(valeur)
#self.val=valeur
self.valeur = valeur
self.val=repr(valeur)
- def interprete_valeur(self,val):
+ def interpreteValeur(self,val):
"""
Essaie d'interpreter val (chaine de caracteres)comme :
- un entier
@@ -137,7 +137,7 @@ class PARAMETRE(N_OBJECT.OBJECT,I_OBJECT.OBJECT,Formula) :
# on retourne val comme une string car on n'a pas su l'interpreter
return val
- def get_valeurs(self):
+ def getValeurs(self):
valeurretour=[]
if self.dict_valeur != []:
for val in self.dict_valeur:
@@ -146,35 +146,35 @@ class PARAMETRE(N_OBJECT.OBJECT,I_OBJECT.OBJECT,Formula) :
valeurretour.append(self.valeur)
return valeurretour
- def set_valeur(self,new_valeur):
+ def setValeur(self,new_valeur):
"""
Remplace la valeur de self par new_valeur interpretee
"""
- self.valeur = self.interprete_valeur(new_valeur)
+ self.valeur = self.interpreteValeur(new_valeur)
self.val=repr(self.valeur)
- self.parent.update_concept_after_etape(self,self)
- self.init_modif()
+ self.parent.updateConceptAfterEtape(self,self)
+ self.initModif()
- def set_nom(self,new_nom):
+ def setNom(self,new_nom):
"""
Change le nom du parametre
"""
- self.init_modif()
+ self.initModif()
self.nom=new_nom
self.fin_modif()
- def init_modif(self):
+ def initModif(self):
"""
Methode qui declare l'objet courant comme modifie et propage
cet etat modifie a ses ascendants
"""
self.state = 'modified'
if self.parent:
- self.parent.init_modif()
+ self.parent.initModif()
- def get_jdc_root(self):
+ def getJdcRoot(self):
if self.parent:
- return self.parent.get_jdc_root()
+ return self.parent.getJdcRoot()
else:
return self
@@ -185,7 +185,7 @@ class PARAMETRE(N_OBJECT.OBJECT,I_OBJECT.OBJECT,Formula) :
self.parent.register_parametre(self)
self.parent.register(self)
- def isvalid(self,cr='non'):
+ def isValid(self,cr='non'):
"""
Retourne 1 si self est valide, 0 sinon
Un parametre est considere comme valide si :
@@ -203,19 +203,19 @@ class PARAMETRE(N_OBJECT.OBJECT,I_OBJECT.OBJECT,Formula) :
return 0
return 1
- def isoblig(self):
+ def isOblig(self):
"""
Indique si self est obligatoire ou non : retourne toujours 0
"""
return 0
- def isrepetable(self):
+ def isRepetable(self):
"""
Indique si self est repetable ou non : retourne toujours 1
"""
return 1
- def liste_mc_presents(self):
+ def listeMcPresents(self):
return []
def supprime(self):
@@ -248,11 +248,11 @@ class PARAMETRE(N_OBJECT.OBJECT,I_OBJECT.OBJECT,Formula) :
"""
self.actif = 0
self.jdc.del_param(self)
- self.jdc.delete_concept_after_etape(self,self)
+ self.jdc.deleteConceptAfterEtape(self,self)
CONNECTOR.Emit(self,"supp",None)
CONNECTOR.Emit(self,"valid")
- def isactif(self):
+ def isActif(self):
"""
Booleenne qui retourne 1 si self est actif, 0 sinon
"""
@@ -264,17 +264,17 @@ class PARAMETRE(N_OBJECT.OBJECT,I_OBJECT.OBJECT,Formula) :
"""
if hasattr(self,nom_attr):
setattr(self,nom_attr,new_valeur)
- self.init_modif()
+ self.initModif()
- def supprime_sdprods(self):
+ def supprimeSdProds(self):
"""
Il faut supprimer le parametre qui a ete entre dans la liste des
parametres du JDC
"""
self.jdc.delete_param(self)
- self.parent.delete_concept(self)
+ self.parent.deleteConcept(self)
- def update_context(self,d):
+ def updateContext(self,d):
"""
Update le dictionnaire d avec le parametre que produit self
"""
@@ -308,7 +308,7 @@ class PARAMETRE(N_OBJECT.OBJECT,I_OBJECT.OBJECT,Formula) :
"""
return self.nom
- def get_sdprods(self,nom_sd):
+ def getSdprods(self,nom_sd):
"""
Retourne les concepts produits par la commande
"""
@@ -317,7 +317,7 @@ class PARAMETRE(N_OBJECT.OBJECT,I_OBJECT.OBJECT,Formula) :
def report(self):
""" Genere l'objet rapport (classe CR) """
self.cr=CR()
- self.isvalid(cr='oui')
+ self.isValid(cr='oui')
return self.cr
def ident(self):
@@ -327,13 +327,13 @@ class PARAMETRE(N_OBJECT.OBJECT,I_OBJECT.OBJECT,Formula) :
"""
return self.nom
- def delete_concept(self,sd):
+ def deleteConcept(self,sd):
pass
- def replace_concept(self,old_sd,sd):
+ def replaceConcept(self,old_sd,sd):
pass
- def verif_condition_bloc(self):
+ def verifConditionBloc(self):
"""
Evalue les conditions de tous les blocs fils possibles
(en fonction du catalogue donc de la definition) de self et
@@ -343,24 +343,24 @@ class PARAMETRE(N_OBJECT.OBJECT,I_OBJECT.OBJECT,Formula) :
"""
return [],[]
- def verif_condition_regles(self,liste_presents):
+ def verifConditionRegles(self,liste_presents):
"""
Retourne la liste des mots-cles a rajouter pour satisfaire les regles
en fonction de la liste des mots-cles presents
"""
return []
- def verif_existence_sd(self):
+ def verifExistenceSd(self):
pass
- def control_sdprods(self,d):
+ def controlSdprods(self,d):
"""sans objet """
pass
def close(self):
pass
- def reset_context(self):
+ def resetContext(self):
pass
def eval(self):
@@ -380,7 +380,7 @@ class COMBI_PARAMETRE(object) :
def __repr__(self):
return self.chainevaleur
- def isvalid(self):
+ def isValid(self):
if self.valeur and self.chainevaleur:
return 1
@@ -394,14 +394,14 @@ class ITEM_PARAMETRE(object) :
return self.param_pere.nom+'['+str(self.item)+']'
- def isvalid(self):
- isvalid = 1
+ def isValid(self):
+ isValid = 1
if self.item < 0:
- isvalid = 0
+ isValid = 0
try:
longueur= len(self.param_pere.dict_valeur) - 1
except:
longueur=0
if self.item > longueur :
- isvalid= 0
- return isvalid
+ isValid= 0
+ return isValid
diff --git a/Extensions/parametre_eval.py b/Extensions/parametre_eval.py
index 1f8e2769..135f839f 100644
--- a/Extensions/parametre_eval.py
+++ b/Extensions/parametre_eval.py
@@ -52,7 +52,7 @@ class PARAMETRE_EVAL(parametre.PARAMETRE) :
# parent ne peut etre qu'un objet de type JDC
import Accas
self.Accas_EVAL=Accas.EVAL
- self.valeur = self.interprete_valeur(valeur)
+ self.valeur = self.interpreteValeur(valeur)
self.val = valeur
self.nom = nom
self.jdc = self.parent = CONTEXT.get_current_step()
@@ -76,7 +76,7 @@ class PARAMETRE_EVAL(parametre.PARAMETRE) :
"""
return self.nom
- def interprete_valeur(self,val):
+ def interpreteValeur(self,val):
"""
Essaie d'interpreter val (chaine de caracteres ou None) comme :
une instance de Accas.EVAL
@@ -95,21 +95,21 @@ class PARAMETRE_EVAL(parametre.PARAMETRE) :
print(("Le texte %s n'est pas celui d'un parametre evalue" %val))
return None
- def set_valeur(self,new_valeur):
+ def setValeur(self,new_valeur):
"""
Remplace la valeur de self par new_valeur interpretee.
"""
- self.valeur = self.interprete_valeur(new_valeur)
+ self.valeur = self.interpreteValeur(new_valeur)
self.val = new_valeur
- self.init_modif()
+ self.initModif()
- def get_nom(self) :
+ def getNom(self) :
"""
Retourne le nom du parametre
"""
return self.nom
- def get_valeur(self):
+ def getValeur(self):
"""
Retourne la valeur de self, cad le texte de l'objet class_eval.EVAL
"""
@@ -118,7 +118,7 @@ class PARAMETRE_EVAL(parametre.PARAMETRE) :
else:
return ''
- def verif_eval(self,exp_eval=None,cr='non'):
+ def verifEval(self,exp_eval=None,cr='non'):
"""
Cette methode a pour but de verifier si l'expression EVAL
est syntaxiquement correcte.
@@ -144,14 +144,14 @@ class PARAMETRE_EVAL(parametre.PARAMETRE) :
if cr == 'oui' :
if not verificateur.cr.estvide():
self.cr.fatal(verificateur.cr.get_mess_fatal())
- return verificateur.isvalid(),''.join(verificateur.cr.crfatal)
+ return verificateur.isValid(),''.join(verificateur.cr.crfatal)
else:
# pas d'expression EVAL --> self non valide
if cr == 'oui' :
self.cr.fatal(tr("Le parametre EVAL %s ne peut valoir None") , self.nom)
return 0,tr("Le parametre EVAL ne peut valoir None")
- def verif_nom(self,nom=None,cr='non'):
+ def verifNom(self,nom=None,cr='non'):
"""
Verifie si le nom passe en argument (si aucun prend le nom courant)
est un nom valide pour un parametre EVAL
@@ -187,8 +187,8 @@ class PARAMETRE_EVAL(parametre.PARAMETRE) :
param = (self.nom,self.valeur.valeur)
else:
param = (self.nom,None)
- test_nom,erreur_nom = self.verif_nom(param[0],cr=cr)
- test_eval,erreur_eval = self.verif_eval(param[1],cr=cr)
+ test_nom,erreur_nom = self.verifNom(param[0],cr=cr)
+ test_eval,erreur_eval = self.verifEval(param[1],cr=cr)
# test global = produit des tests partiels
test = test_nom*test_eval
# message d'erreurs global = concatenation des messages partiels
@@ -205,11 +205,11 @@ class PARAMETRE_EVAL(parametre.PARAMETRE) :
par les nouvelles valeurs passees dans le tuple formule.
On stocke les valeurs SANS verifications.
"""
- self.init_modif()
- self.set_nom(param[0])
- self.set_valeur('EVAL("""'+param[1]+'""")')
+ self.initModif()
+ self.setNom(param[0])
+ self.setValeur('EVAL("""'+param[1]+'""")')
- def isvalid(self,cr='non'):
+ def isValid(self,cr='non'):
"""
Retourne 1 si self est valide, 0 sinon
Un parametre evalue est considere comme valide si :
@@ -224,10 +224,10 @@ class PARAMETRE_EVAL(parametre.PARAMETRE) :
Genere l'objet rapport (classe CR)
"""
self.cr = CR()
- self.isvalid(cr='oui')
+ self.isValid(cr='oui')
return self.cr
- def set_nom(self,new_nom):
+ def setNom(self,new_nom):
"""
Remplace le nom de self par new_nom
"""
diff --git a/InterfaceQT4/browser.py b/InterfaceQT4/browser.py
index 760b6cc7..17e6d777 100644
--- a/InterfaceQT4/browser.py
+++ b/InterfaceQT4/browser.py
@@ -24,14 +24,15 @@ try :
from builtins import str
from builtins import range
except : pass
+
import re
import types,sys,os
import traceback
from . import typeNode
-#import pdb
import six
from six.moves import range
+
from PyQt5.QtWidgets import QTreeWidget , QTreeWidgetItem, QApplication, QMessageBox
from PyQt5.QtGui import QIcon
from PyQt5.QtCore import Qt
@@ -39,7 +40,10 @@ from Extensions.i18n import tr
from .gereRegles import GereRegles
from .monChoixCommande import MonChoixCommande
+#------------------------------------------
class JDCTree( QTreeWidget,GereRegles ):
+#------------------------------------------
+
def __init__( self, jdc_item, QWParent):
#if hasattr(QWParent,'widgetTree') :
self.editor = QWParent
@@ -107,7 +111,7 @@ class JDCTree( QTreeWidget,GereRegles ):
if item.menu == None:
item.createPopUpMenu()
if item.menu != None:
- if item.item.get_nom() == "DISTRIBUTION" and item.item.isvalid() :
+ if item.item.getNom() == "DISTRIBUTION" and item.item.isValid() :
item.Graphe.setEnabled(1)
item.menu.exec_(coord)
@@ -177,8 +181,8 @@ class JDCTree( QTreeWidget,GereRegles ):
#print 'il faut afficher le 1er'
try :
- fr = item.item.get_fr()
- if self.editor: self.editor.affiche_commentaire(six.text_type(fr))
+ fr = item.item.getFr()
+ if self.editor: self.editor.afficheCommentaire(six.text_type(fr))
except:
pass
item.select()
@@ -195,10 +199,14 @@ class JDCTree( QTreeWidget,GereRegles ):
COMMENT = "COMMENTAIRE"
PARAMETERS = "PARAMETRE"
+#------------------------------------------
class JDCNode(QTreeWidgetItem,GereRegles):
+#------------------------------------------
def __init__( self, treeParent, item, itemExpand=False, ancien=False ):
- #print "creation d'un noeud : ", item, " ",item.nom,"", treeParent, self
+ #print ("creation d'un noeud : ", item, " ",item.nom,"", treeParent, self)
#self.a=0
+
+
self.item = item
self.vraiParent = treeParent
self.treeParent = treeParent
@@ -213,11 +221,11 @@ class JDCNode(QTreeWidgetItem,GereRegles):
from InterfaceQT4 import compoparam
from InterfaceQT4 import composimp
if (isinstance(self.item,compocomm.COMMTreeItem)) : name=tr("Commentaire")
- elif (isinstance(self.item,compoparam.PARAMTreeItem)) : name=tr(str(item.GetLabelText()[0]))
- #else: name = tr(str(tr(item.GetLabelText()[0]))+" :")
- else: name = tr(item.GetLabelText()[0])
+ elif (isinstance(self.item,compoparam.PARAMTreeItem)) : name=tr(str(item.getLabelText()[0]))
+ #else: name = tr(str(tr(item.getLabelText()[0]))+" :")
+ else: name = tr(item.getLabelText()[0])
if item.nom != tr(item.nom) : name = str(tr(item.nom)+" :")
- value = tr(str( item.GetText() ) )
+ value = tr(str( item.getText() ) )
if self.editor.enteteQTree=='complet':mesColonnes=(name,value)
@@ -254,15 +262,18 @@ class JDCNode(QTreeWidgetItem,GereRegles):
else :
QTreeWidgetItem.__init__(self,self.treeParent,mesColonnes)
- self.setToolTip(0,self.item.get_fr())
- self.setToolTip(1,self.item.get_fr())
+ self.setToolTip(0,self.item.getFr())
+ self.setToolTip(1,self.item.getFr())
repIcon=self.appliEficas.repIcon
- monIcone = QIcon(repIcon+"/" +self.item.GetIconName() + ".png")
+ couleur=self.item.getIconName()
+ if not self.editor.configuration.differencieSiDefaut and couleur == 'ast-green-dark-ball' : couleur="ast-green-ball"
+ monIcone = QIcon(repIcon+"/" + couleur + ".png")
+
self.setIcon(0,monIcone)
self.children = []
- self.build_children()
+ self.buildChildren()
self.menu=None
self.existeMenu=1
@@ -280,10 +291,11 @@ class JDCNode(QTreeWidgetItem,GereRegles):
pass
- def build_children(self,posInsertion=10000):
+ def buildChildren(self,posInsertion=10000):
""" Construit la liste des enfants de self """
""" Se charge de remettre les noeuds Expanded dans le meme etat """
- #print "*********** build_children ",self,self.item, self.item.nom
+ #print ("*********** buildChildren ",self,self.item, self.item.nom)
+ #print (poum)
self.listeItemExpanded=[]
self.listeItemPlie=[]
@@ -300,7 +312,7 @@ class JDCNode(QTreeWidgetItem,GereRegles):
self.children = []
self.childrenComplete = []
- sublist = self.item._GetSubList()
+ sublist = self.item._getSubList()
ind=0
for item in sublist :
@@ -311,22 +323,50 @@ class JDCNode(QTreeWidgetItem,GereRegles):
nouvelItem=item.itemNode(self,item,itemExpand,ancien)
self.children.append(nouvelItem)
- #print "fin *********** build_children ",self,self.item, self.item.nom, self.children
+ #print ("fin *********** buildChildren ",self,self.item, self.item.nom, self.children)
def chercheNoeudCorrespondant(self,objSimp):
- sublist = self.item._GetSubList()
+ sublist = self.item._getSubList()
for node in self.childrenComplete:
if node.item.object==objSimp : return node
return None
+ def deplieCeNiveau(self):
+
+ if self.fenetre == None :
+ print ('PNPNPN a programmer')
+ #self.fenetre=self.getPanelGroupe(self.editor)
+ #print ((self.item.panel))
+ print (self.fenetre)
+ for indiceWidget in range(self.editor.widgetCentraleLayout.count()):
+ widget=self.editor.widgetCentraleLayout.itemAt(indiceWidget)
+ self.editor.widgetCentraleLayout.removeItem(widget)
+ if self.editor.fenetreCentraleAffichee != None :
+ self.editor.widgetCentraleLayout.removeWidget(self.editor.fenetreCentraleAffichee)
+ self.editor.fenetreCentraleAffichee.setParent(None)
+ self.editor.fenetreCentraleAffichee.close()
+ self.editor.fenetreCentraleAffichee.deleteLater()
+
+ from monWidgetNiveauFact import MonWidgetNiveauFact
+ maDefinition=self.item.get_definition()
+ monObjet=self.item.object
+ self.maFenetreCadre=MonWidgetNiveauFact(self,self.editor,maDefinition,monObjet)
+ #self.maFenetreCadre.commandesLayout.insertWidget(-1,self.fenetre)
+ self.editor.widgetCentraleLayout.addWidget(self.maFenetreCadre)
+ #print ("j ajoute ", self.fenetre, self.fenetre.node.item.nom)
+ self.editor.fenetreCentraleAffichee=self.maFenetreCadre
+ self.tree.node_selected= self
+
+
+
def affichePanneau(self) :
- #if self.editor.code == 'ASTER' and not(self.item.isactif()) :
+ #if self.editor.code == 'ASTER' and not(self.item.isActif()) :
# posera des pb si un code decide d appeler FIN un mot clef
# on resoudera a ce moment la
# pour l instant pas de poussiere sous le tapis
- if not(self.item.isactif()) :
+ if not(self.item.isActif()) :
from .monWidgetInactif import MonWidgetInactif
self.fenetre = MonWidgetInactif(self,self.editor)
else:
@@ -374,10 +414,10 @@ class JDCNode(QTreeWidgetItem,GereRegles):
# (commentariser) un commentaire.
try :
pos=self.treeParent.children.index(self)
- commande_comment = self.item.get_objet_commentarise()
+ commande_comment = self.item.getObjetCommentarise()
# On signale a l editeur du panel (le JDCDisplay) une modification
- self.editor.init_modif()
- self.treeParent.build_children()
+ self.editor.initModif()
+ self.treeParent.buildChildren()
self.treeParent.children[pos].select()
self.treeParent.children[pos].affichePanneau()
except Exception as e:
@@ -390,9 +430,9 @@ class JDCNode(QTreeWidgetItem,GereRegles):
"""
try :
pos=self.treeParent.children.index(self)
- commande,nom = self.item.uncomment()
- self.editor.init_modif()
- self.treeParent.build_children()
+ commande,nom = self.item.unComment()
+ self.editor.initModif()
+ self.treeParent.buildChildren()
self.treeParent.children[pos].select()
self.treeParent.children[pos].affichePanneau()
except Exception as e:
@@ -402,7 +442,7 @@ class JDCNode(QTreeWidgetItem,GereRegles):
"""
Ajoute un commentaire a l'interieur du JDC :
"""
- self.editor.init_modif()
+ self.editor.initModif()
if after:
pos = 'after'
else:
@@ -413,7 +453,7 @@ class JDCNode(QTreeWidgetItem,GereRegles):
"""
Ajoute un parametre a l'interieur du JDC :
"""
- self.editor.init_modif()
+ self.editor.initModif()
if after: pos = 'after'
else: pos = 'before'
child=self.appendBrother( PARAMETERS, pos )
@@ -440,7 +480,7 @@ class JDCNode(QTreeWidgetItem,GereRegles):
par defaut on l'ajoute immediatement apres
Methode externe
"""
- self.editor.init_modif()
+ self.editor.initModif()
from InterfaceQT4 import compojdc
if (isinstance(self.treeParent, compojdc.Node)) and not self.verifiePosition(name,pos) : return 0
@@ -449,7 +489,7 @@ class JDCNode(QTreeWidgetItem,GereRegles):
index = self.vraiParent.children.index(self)
if pos == 'before': index = index
elif pos == 'after': index = index +1
- return self.vraiParent.append_child(name,pos=index,plier=plier)
+ return self.vraiParent.appendChild(name,pos=index,plier=plier)
else :
index = self.treeParent.children.index(self)
if pos == 'before': index = index
@@ -457,13 +497,13 @@ class JDCNode(QTreeWidgetItem,GereRegles):
else:
print(six.text_type(pos), tr(" n'est pas un index valide pour appendBrother"))
return 0
- return self.treeParent.append_child(name,pos=index,plier=plier)
+ return self.treeParent.appendChild(name,pos=index,plier=plier)
def verifiePosition(self,name,pos,aLaRacine=False):
if name not in self.editor.Classement_Commandes_Ds_Arbre : return True
indexName=self.editor.Classement_Commandes_Ds_Arbre.index(name)
- etapes=self.item.get_jdc().etapes
+ etapes=self.item.getJdc().etapes
if etapes == [] : return True
if aLaRacine == False :indexOu=etapes.index(self.item.object)
@@ -488,19 +528,19 @@ class JDCNode(QTreeWidgetItem,GereRegles):
return False
return True
- def append_child(self,name,pos=None,plier=False):
+ def appendChild(self,name,pos=None,plier=False):
"""
Methode pour ajouter un objet fils a l'objet associe au noeud self.
On peut l'ajouter en debut de liste (pos='first'), en fin (pos='last')
ou en position intermediaire.
Si pos vaut None, on le place a la position du catalogue.
"""
- #print ("************** append_child ",self.item.GetLabelText(), plier)
+ #print ("************** appendChild ",self.item.getLabelText(), pos, plier)
#import traceback
#traceback.print_stack()
- self.editor.init_modif()
+ self.editor.initModif()
if pos == 'first':
index = 0
elif pos == 'last':
@@ -510,11 +550,11 @@ class JDCNode(QTreeWidgetItem,GereRegles):
index = pos
elif type(pos) == types.InstanceType:
# pos est un item. Il faut inserer name apres pos
- index = self.item.get_index(pos) +1
+ index = self.item.getIndex(pos) +1
elif type(name) == types.InstanceType:
- index = self.item.get_index_child(name.nom)
+ index = self.item.getIndex_child(name.nom)
else:
- index = self.item.get_index_child(name)
+ index = self.item.getIndex_child(name)
# si on essaye d inserer a la racine
if (isinstance(self.treeParent,JDCTree) and index==0) :
@@ -522,7 +562,7 @@ class JDCNode(QTreeWidgetItem,GereRegles):
if not verifiePosition : return 0
self.tree.inhibeExpand=True
- obj=self.item.additem(name,index) # emet le signal 'add'
+ obj=self.item.addItem(name,index) # emet le signal 'add'
if obj is None:obj=0
if obj == 0:return 0
try :
@@ -533,14 +573,14 @@ class JDCNode(QTreeWidgetItem,GereRegles):
except :
child=self.children[index]
try :
- if len(obj) > 1 : self.build_children()
+ if len(obj) > 1 : self.buildChildren()
except : pass
self.tree.inhibeExpand=False
#print (" fin append child")
return child
def deplace(self):
- self.editor.init_modif()
+ self.editor.initModif()
index = self.treeParent.children.index(self) - 1
if index < 0 : index =0
ret=self.treeParent.item.deplaceEntite(self.item.getObject())
@@ -549,19 +589,19 @@ class JDCNode(QTreeWidgetItem,GereRegles):
"""
Methode externe pour la destruction de l'objet associe au noeud
"""
- self.editor.init_modif()
+ self.editor.initModif()
index = self.vraiParent.children.index(self) - 1
if index < 0 : index =0
recalcule=0
if self.item.nom == "VARIABLE" :
recalcule=1
jdc=self.item.jdc
- ret,commentaire=self.vraiParent.item.suppitem(self.item)
+ ret,commentaire=self.vraiParent.item.suppItem(self.item)
if ret==0 :
- self.editor.affiche_infos(commentaire,Qt.red)
+ self.editor.afficheInfos(commentaire,Qt.red)
else :
- self.editor.affiche_infos(commentaire)
- self.treeParent.build_children()
+ self.editor.afficheInfos(commentaire)
+ self.treeParent.buildChildren()
if self.treeParent.childrenComplete : toselect=self.treeParent.childrenComplete[index]
else: toselect=self.treeParent
if recalcule : jdc.recalcule_etat_correlation()
@@ -585,7 +625,7 @@ class JDCNode(QTreeWidgetItem,GereRegles):
Methode externe pour la destruction d une liste de noeud
"""
from InterfaceQT4 import compojdc
- self.editor.init_modif()
+ self.editor.initModif()
index=9999
recalcule=0
jdc=self.treeParent
@@ -606,9 +646,9 @@ class JDCNode(QTreeWidgetItem,GereRegles):
parentPosition=parentPosition.treeParent
for noeud in liste:
- noeud.treeParent.item.suppitem(noeud.item)
+ noeud.treeParent.item.suppItem(noeud.item)
- jdc.build_children()
+ jdc.buildChildren()
if recalcule : jdc.recalcule_etat_correlation()
try : toselect=parentPosition.children[index]
except : toselect=jdc
@@ -618,7 +658,7 @@ class JDCNode(QTreeWidgetItem,GereRegles):
# #------------------------------------------------------------------
def onValid(self):
- #print "onValid pour ", self.item.nom
+ #print ("onValid pour ", self.item.nom)
if self.JESUISOFF==1 : return
if hasattr(self,'fenetre') and self.fenetre:
try :
@@ -627,113 +667,116 @@ class JDCNode(QTreeWidgetItem,GereRegles):
# print "onValid pour ", self.item.nom, self,'pb'
pass
- if (self.item.nom == "VARIABLE" or self.item.nom == "DISTRIBUTION") and self.item.isvalid():
+ if (self.item.nom == "VARIABLE" or self.item.nom == "DISTRIBUTION") and self.item.isValid():
self.item.jdc.recalcule_etat_correlation()
if hasattr(self.item,'forceRecalcul'):
self.forceRecalculChildren(self.item.forceRecalcul)
- self.editor.init_modif()
+ self.editor.initModif()
- self.update_node_valid()
- self.update_node_label()
- self.update_node_texte()
+ self.updateNodeValid()
+ self.updateNodeLabel()
+ self.updateNodeTexte()
def onAdd(self,object):
if self.JESUISOFF==1 : return
#print "onAdd pour ", self.item.nom, object.nom
- self.editor.init_modif()
- self.update_nodes()
+ self.editor.initModif()
+ self.updateNodes()
# PN -- non necessaire si item=jdc
if hasattr(self.item,'jdc'): self.item.jdc.aReafficher=True
def onSupp(self,object):
if self.JESUISOFF==1 : return
#print "onSup pour ", self.item.nom, object.nom
- self.editor.init_modif()
- self.update_nodes()
+ self.editor.initModif()
+ self.updateNodes()
# PN -- non necessaire si item=jdc
if hasattr(self.item,'jdc'): self.item.jdc.aReafficher=True
- def update_node_valid(self):
+ def updateNodeValid(self):
"""Cette methode remet a jour la validite du noeud (icone)
- Elle appelle isvalid
+ Elle appelle isValid
"""
repIcon=self.appliEficas.repIcon
- monIcone = QIcon(repIcon+"/" +self.item.GetIconName() + ".png")
+ couleur=self.item.getIconName()
+ if not self.editor.configuration.differencieSiDefaut and couleur == 'ast-green-dark-ball' : couleur="ast-green-ball"
+ monIcone = QIcon(repIcon+"/" + couleur + ".png")
self.setIcon(0,monIcone)
- def update_node_label(self):
+
+ def updateNodeLabel(self):
""" Met a jour le label du noeud """
- #print "NODE update_node_label", self.item.GetLabelText()
- labeltext,fonte,couleur = self.item.GetLabelText()
+ #print "NODE updateNodeLabel", self.item.getLabelText()
+ labeltext,fonte,couleur = self.item.getLabelText()
# PNPN a reflechir
self.setText(0, labeltext)
- def update_node_label_in_black(self):
+ def updateNodeLabelInBlack(self):
if hasattr(self.appliEficas,'noeudColore'):
self.appliEficas.noeudColore.setForeground(0,Qt.black)
- self.appliEficas.noeudColore.update_node_label
+ self.appliEficas.noeudColore.updateNodeLabel
- def update_node_label_in_blue(self):
+ def updateNodeLabelInBlue(self):
if hasattr(self.appliEficas,'noeudColore'): self.appliEficas.noeudColore.setForeground(0,Qt.black)
self.setForeground(0,Qt.blue)
- labeltext,fonte,couleur = self.item.GetLabelText()
+ labeltext,fonte,couleur = self.item.getLabelText()
self.setText(0, labeltext)
self.appliEficas.noeudColore=self
- def update_plusieurs_node_label_in_blue(self,liste):
+ def updatePlusieursNodeLabelInBlue(self,liste):
if hasattr(self.appliEficas,'listeNoeudsColores'):
for noeud in self.appliEficas.listeNoeudsColores:
noeud.setTextColor( 0,Qt.black)
- noeud.update_node_label()
+ noeud.updateNodeLabel()
self.appliEficas.listeNoeudsColores=[]
for noeud in liste :
noeud.setTextColor( 0,Qt.blue )
- labeltext,fonte,couleur = noeud.item.GetLabelText()
+ labeltext,fonte,couleur = noeud.item.getLabelText()
noeud.setText(0, labeltext)
self.appliEficas.listeNoeudsColores.append(noeud)
- def update_node_texte_in_black(self):
+ def updateNodeTexteInBlack(self):
""" Met a jour les noms des SD et valeurs des mots-cles """
self.setTextColor( 1,Qt.black )
- value = self.item.GetText()
+ value = self.item.getText()
self.setText(1, value)
- def update_node_texte(self):
+ def updateNodeTexte(self):
""" Met a jour les noms des SD et valeurs des mots-cles """
- value = self.item.GetText()
+ value = self.item.getText()
self.setText(1, value)
- def update_node_texte_in_blue(self):
+ def updateNodeTexteInBlue(self):
self.setTextColor( 1,Qt.blue )
- value = self.item.GetText()
+ value = self.item.getText()
self.setText(1, value)
- def update_nodes(self):
- #print 'NODE update_nodes', self.item.GetLabelText()
- self.build_children()
+ def updateNodes(self):
+ #print 'NODE updateNodes', self.item.getLabelText()
+ self.buildChildren()
- def update_valid(self) :
+ def updateValid(self) :
"""Cette methode a pour but de mettre a jour la validite du noeud
et de propager la demande de mise a jour a son parent
"""
- #print "NODE update_valid", self.item.GetLabelText()
- self.update_node_valid()
+ #print "NODE updateValid", self.item.getLabelText()
+ self.updateNodeValid()
try :
- self.treeParent.update_valid()
+ self.treeParent.updateValid()
except:
pass
- def update_texte(self):
+ def updateTexte(self):
""" Met a jour les noms des SD et valeurs des mots-cles """
- #print "NODE update_texte", self.item.GetLabelText()
- self.update_node_texte()
+ #print "NODE updateTexte", self.item.getLabelText()
+ self.updateNodeVexte()
if self.isExpanded() :
for child in self.children:
- if child.isHidden() == false : child.update_texte()
+ if child.isHidden() == false : child.updateTexte()
def forceRecalculChildren(self,niveau):
@@ -753,10 +796,10 @@ class JDCNode(QTreeWidgetItem,GereRegles):
Declenche la copie de l'objet item avec pour cible
l'objet passe en argument : node_selected
"""
- objet_a_copier = self.item.get_copie_objet()
+ objet_a_copier = self.item.getCopieObjet()
child=node_selected.doPasteCommande(objet_a_copier,pos)
if self.editor.fenetreCentraleAffichee : self.editor.fenetreCentraleAffichee.node.affichePanneau()
- self.update_node_label_in_black()
+ self.updateNodeLabelInBlack()
return child
def doPasteCommande(self,objet_a_copier,pos='after'):
@@ -776,12 +819,12 @@ class JDCNode(QTreeWidgetItem,GereRegles):
"""
Realise la copie de l'objet passe en argument (objet_a_copier)
"""
- objet = objet_a_copier.item.get_copie_objet()
- child = self.append_child(objet,pos='first')
+ objet = objet_a_copier.item.getCopieObjet()
+ child = self.appendChild(objet,pos='first')
return child
def plieToutEtReafficheSaufItem(self, itemADeplier):
- #print "je suis dans plieToutEtReaffiche", self.item.get_nom()
+ #print "je suis dans plieToutEtReaffiche", self.item.getNom()
self.inhibeExpand=True
from InterfaceQT4 import compojdc
if (isinstance(self, compojdc.Node)) :
@@ -819,7 +862,7 @@ class JDCNode(QTreeWidgetItem,GereRegles):
def setPlie(self):
#print "je mets inhibeExpand a true dans setPlie"
- #print "je suis dans plieTout", self.item.get_nom()
+ #print "je suis dans plieTout", self.item.getNom()
from . import compojdc
if self.fenetre == self.editor.fenetreCentraleAffichee and isinstance(self.treeParent,compojdc.Node):
return
@@ -840,7 +883,7 @@ class JDCNode(QTreeWidgetItem,GereRegles):
self.plie=True
for c in self.children :
c.setPlieChildren()
- #print "dans setPlieChildren appartientAUnNoeudPlie=True ", c, c.item.GetLabelText()[0]
+ #print "dans setPlieChildren appartientAUnNoeudPlie=True ", c, c.item.getLabelText()[0]
c.appartientAUnNoeudPlie=True
c.plie=True
#print "dans setPlieChildren plie", c.item.nom
@@ -856,7 +899,7 @@ class JDCNode(QTreeWidgetItem,GereRegles):
niveauPere=niveauPere.treeParent
for c in self.children :
c.appartientAUnNoeudPlie=niveauPere.appartientAUnNoeudPlie
- #print "dans setPlieChildren appartientAUnNoeudPlie=True ", c, c.item.GetLabelText()[0], "mis a la valeur ", niveauPere.appartientAUnNoeudPlie
+ #print "dans setPlieChildren appartientAUnNoeudPlie=True ", c, c.item.getLabelText()[0], "mis a la valeur ", niveauPere.appartientAUnNoeudPlie
c.setExpanded(False)
# on affiche un niveau de plus
@@ -879,7 +922,7 @@ class JDCNode(QTreeWidgetItem,GereRegles):
#print "je mets inhibeExpand a false dans setDePlie"
def setDeplieChildren(self):
- #print "dans setDeplieChildren appartientAUnNoeudPlie=False ", self.item.GetLabelText()
+ #print "dans setDeplieChildren appartientAUnNoeudPlie=False ", self.item.getLabelText()
for c in self.children :
c.setDeplieChildren()
#print "dans setDeplieChildren ", c.item.nom
diff --git a/InterfaceQT4/compobloc.py b/InterfaceQT4/compobloc.py
index df06e88d..b8bf53c0 100644
--- a/InterfaceQT4/compobloc.py
+++ b/InterfaceQT4/compobloc.py
@@ -48,12 +48,12 @@ class Node(browser.JDCNode,typeNode.PopUpMenuNodeMinimal):
class BLOCTreeItem(compofact.FACTTreeItem):
itemNode=Node
- def get_objet(self,name) :
- for v in self.object.mc_liste:
- if v.nom == name : return v
- return None
+ #def get_objet(self,name) :
+ # for v in self.object.mc_liste:
+ # if v.nom == name : return v
+ # return None
- def iscopiable(self):
+ def isCopiable(self):
return 0
diff --git a/InterfaceQT4/compocomm.py b/InterfaceQT4/compocomm.py
index e699a334..cedfadce 100644
--- a/InterfaceQT4/compocomm.py
+++ b/InterfaceQT4/compocomm.py
@@ -38,21 +38,21 @@ class Node(browser.JDCNode,typeNode.PopUpMenuNodePartiel):
def createPopUpMenu(self):
typeNode.PopUpMenuNodePartiel.createPopUpMenu(self)
- self.Decommente = QAction(tr("Decommenter"),self.tree)
- self.Decommente.triggered.connect(self.Decommenter)
+ self.Decommente = QAction(tr("decommenter"),self.tree)
+ self.Decommente.triggered.connect(self.decommenter)
self.Decommente.setStatusTip(tr("Decommente la commande "))
- if hasattr(self.item,'uncomment'):
+ if hasattr(self.item,'unComment'):
self.menu.addAction(self.Decommente)
- def Decommenter(self) :
+ def decommenter(self) :
item= self.tree.currentItem()
item.unCommentIt()
- def update_node_label(self) :
+ def updateNodeLabel(self) :
"""
"""
- debComm=self.item.GetText()
+ debComm=self.item.getText()
self.setText(1,debComm)
@@ -61,9 +61,9 @@ class COMMTreeItem(Objecttreeitem.ObjectTreeItem):
itemNode=Node
def init(self):
- self.setfunction = self.set_valeur
+ self.setFunction = self.setValeur
- def GetIconName(self):
+ def getIconName(self):
"""
Retourne le nom de l'icone associee au noeud qui porte self,
dependant de la validite de l'objet
@@ -71,7 +71,7 @@ class COMMTreeItem(Objecttreeitem.ObjectTreeItem):
"""
return "ast-white-percent"
- def GetLabelText(self):
+ def getLabelText(self):
""" Retourne 3 valeurs :
- le texte a afficher dans le noeud representant l'item
- la fonte dans laquelle afficher ce texte
@@ -79,13 +79,13 @@ class COMMTreeItem(Objecttreeitem.ObjectTreeItem):
"""
return tr('Commentaire'),None,None
- def get_valeur(self):
+ def getValeur(self):
"""
Retourne la valeur de l'objet Commentaire cad son texte
"""
- return self.object.get_valeur() or ''
+ return self.object.getValeur() or ''
- def GetText(self):
+ def getText(self):
texte = self.object.valeur
texte = texte.split('\n')[0]
if len(texte) < 25 :
@@ -93,23 +93,23 @@ class COMMTreeItem(Objecttreeitem.ObjectTreeItem):
else :
return texte[0:24]
- def set_valeur(self,valeur):
+ def setValeur(self,valeur):
"""
Affecte valeur a l'objet COMMENTAIRE
"""
- self.object.set_valeur(valeur)
+ self.object.setValeur(valeur)
- def GetSubList(self):
+ def getSubList(self):
"""
Retourne la liste des fils de self
"""
return []
- def get_objet_commentarise(self):
+ def getObjetCommentarise(self):
"""
- La methode get_objet_commentarise() de la classe compocomm.COMMTreeItem
- surcharge la methode get_objet_commentarise de la classe Objecttreeitem.ObjectTreeItem
+ La methode getObjetCommentarise() de la classe compocomm.COMMTreeItem
+ surcharge la methode getObjetCommentarise de la classe Objecttreeitem.ObjectTreeItem
elle a pour but d'empecher l'utilisateur final de commentariser un commentaire.
"""
raise EficasException( 'Impossible de commentariser un commentaire' )
diff --git a/InterfaceQT4/compocommandecomm.py b/InterfaceQT4/compocommandecomm.py
index 191057bb..41eed95a 100644
--- a/InterfaceQT4/compocommandecomm.py
+++ b/InterfaceQT4/compocommandecomm.py
@@ -28,20 +28,20 @@ class COMMANDE_COMMTreeItem(Objecttreeitem.ObjectTreeItem):
itemNode=compocomm.Node
def init(self):
- self.setfunction = self.set_valeur
+ self.setFunction = self.setValeur
- def GetIconName(self):
+ def getIconName(self):
"""
Retourne le nom de l'icone associee au noeud qui porte self,
dependant de la validite de l'objet
NB : une commande commentarisee est toujours valide ...
"""
- if self.isvalid():
+ if self.isValid():
return "ast-green-percent"
else:
return "ast-red-percent"
- def GetLabelText(self):
+ def getLabelText(self):
""" Retourne 3 valeurs :
- le texte a afficher dans le noeud representant l'item
- la fonte dans laquelle afficher ce texte
@@ -49,13 +49,13 @@ class COMMANDE_COMMTreeItem(Objecttreeitem.ObjectTreeItem):
"""
return 'commentaire'
- def get_valeur(self):
+ def getValeur(self):
"""
Retourne la valeur de la commande commentarisee cad son texte
"""
- return self.object.get_valeur() or ''
+ return self.object.getValeur() or ''
- def GetText(self):
+ def getText(self):
texte = self.object.valeur
texte = texte.split('\n')[0]
if len(texte) < 25 :
@@ -63,26 +63,26 @@ class COMMANDE_COMMTreeItem(Objecttreeitem.ObjectTreeItem):
else :
return texte[0:24]
- def set_valeur(self,valeur):
+ def setValeur(self,valeur):
"""
Afefcte valeur a l'objet commande commentarisee
"""
- self.object.set_valeur(valeur)
+ self.object.setValeur(valeur)
- def GetSubList(self):
+ def getSubList(self):
"""
Retourne la liste des fils de self
"""
return []
- def uncomment(self):
+ def unComment(self):
"""
Demande a l'objet commande commentarisee de se decommentariser.
Si l'operation s'effectue correctement, retourne l'objet commande
et eventuellement le nom de la sd produite, sinon leve une exception
"""
try:
- commande,nom = self.object.uncomment()
+ commande,nom = self.object.unComment()
#self.parent.children[pos].select()
except Exception as e:
traceback.print_exc()
diff --git a/InterfaceQT4/compofact.py b/InterfaceQT4/compofact.py
index b9eee20d..3103c583 100644
--- a/InterfaceQT4/compofact.py
+++ b/InterfaceQT4/compofact.py
@@ -59,13 +59,13 @@ class Node(browser.JDCNode,typeNode.PopUpMenuNodePartiel):
class FACTTreeItem(Objecttreeitem.ObjectTreeItem):
itemNode=Node
- def IsExpandable(self):
+ def isExpandable(self):
return 1
- def GetText(self):
+ def getText(self):
return ''
- def GetLabelText(self):
+ def getLabelText(self):
""" Retourne 3 valeurs :
- le texte à afficher dans le noeud representant l'item
- la fonte dans laquelle afficher ce texte
@@ -75,16 +75,16 @@ class FACTTreeItem(Objecttreeitem.ObjectTreeItem):
if not(hasattr(self.object,'getlabeltext')): return self.object.nom,None,None
return self.object.getlabeltext(),None,None
- def isvalid(self):
- return self.object.isvalid()
+ def isValid(self):
+ return self.object.isValid()
- def iscopiable(self):
+ def isCopiable(self):
return 1
- def GetIconName(self):
- if self.object.isvalid():
+ def getIconName(self):
+ if self.object.isValid():
return "ast-green-los"
- elif self.object.isoblig():
+ elif self.object.isOblig():
return "ast-red-los"
else:
return "ast-yel-los"
@@ -94,7 +94,7 @@ class FACTTreeItem(Objecttreeitem.ObjectTreeItem):
# keys=self.object.mc_dict
# return keys
- def GetSubList(self):
+ def getSubList(self):
"""
Reactualise la liste des items fils stockes dans self.sublist
"""
@@ -113,20 +113,20 @@ class FACTTreeItem(Objecttreeitem.ObjectTreeItem):
for obj in liste:
if sublist[pos] is None:
# nouvel objet : on cree un nouvel item
- def setfunction(value, object=obj):
+ def setFunction(value, object=obj):
object.setval(value)
- item = self.make_objecttreeitem(self.appli, obj.nom + " : ", obj, setfunction)
+ item = self.makeObjecttreeitem(self.appli, obj.nom + " : ", obj, setFunction)
sublist[pos]=item
pos=pos+1
self.sublist=sublist
return self.sublist
- def additem(self,name,pos):
- objet = self.object.addentite(name,pos)
+ def addItem(self,name,pos):
+ objet = self.object.addEntite(name,pos)
return objet
- def suppitem(self,item) :
+ def suppItem(self,item) :
"""
Cette methode a pour fonction de supprimer l'item passee en argument
des fils de l'item FACT qui est son pere
@@ -134,16 +134,13 @@ class FACTTreeItem(Objecttreeitem.ObjectTreeItem):
- item.getObject() = MCSIMP ou MCBLOC
"""
itemobject=item.getObject()
- if itemobject.isoblig() :
- #self.editor.affiche_infos(tr('Impossible de supprimer un mot-cle obligatoire '),Qt.red)
+ if itemobject.isOblig() :
return (0, tr('Impossible de supprimer un mot-cle obligatoire '))
- if self.object.suppentite(itemobject):
+ if self.object.suppEntite(itemobject):
message = tr("Mot-cle %s supprime")+ six.text_type(itemobject.nom)
- #self.editor.affiche_commentaire(message)
return (1, message)
else:
- #self.editor.affiche_infos(tr('Pb interne : impossible de supprimer ce mot-cle'),Qt.red)
return (0,tr('Pb interne : impossible de supprimer ce mot-cle'))
import Accas
diff --git a/InterfaceQT4/compoformule.py b/InterfaceQT4/compoformule.py
index 6142c55b..3e265a74 100644
--- a/InterfaceQT4/compoformule.py
+++ b/InterfaceQT4/compoformule.py
@@ -49,12 +49,12 @@ class FORMULETreeItem(compooper.EtapeTreeItem):
itemNode=FormuleNode
def init(self):
- self.setfunction = self.set_valeur
+ self.setFunction = self.setValeur
# ---------------------------------------------------------------------------
# API de FORMULE pour l'arbre
# ---------------------------------------------------------------------------
- def GetSubList(self):
+ def getSubList(self):
"""
Retourne la liste des fils de self
On considere que FORMULE n'a pas de fils
@@ -64,27 +64,27 @@ class FORMULETreeItem(compooper.EtapeTreeItem):
# de facon traditionnelle
return []
- def GetIconName(self):
+ def getIconName(self):
"""
Retourne le nom de l'icone a afficher dans l'arbre
Ce nom depend de la validite de l'objet
"""
- if self.object.isactif():
- if self.object.isvalid():
+ if self.object.isActif():
+ if self.object.isValid():
return "ast-green-square"
else:
return "ast-red-square"
else:
return "ast-white-text"
- def GetLabelText(self):
+ def getLabelText(self):
""" Retourne 3 valeurs :
- le texte a afficher dans le noeud representant l'item
- la fonte dans laquelle afficher ce texte
- la couleur du texte
"""
return self.labeltext,None,None
- #if self.object.isactif():
+ #if self.object.isActif():
# None --> fonte et couleur par defaut
# return tr(self.labeltext),None,None
#else:
@@ -96,19 +96,19 @@ class FORMULETreeItem(compooper.EtapeTreeItem):
# du parametre = API graphique de la FORMULE pour Panel et EFICAS
# ---------------------------------------------------------------------------
- def get_nom(self):
+ def getNom(self):
"""
Retourne le nom de la FORMULE
"""
- return self.object.get_nom()
+ return self.object.getNom()
- def get_type(self):
+ def getType(self):
"""
Retourne le type de la valeur retournee par la FORMULE
"""
return self.object.type_retourne
- def get_args(self):
+ def getArgs(self):
"""
Retourne les arguments de la FORMULE
"""
@@ -127,7 +127,7 @@ class FORMULETreeItem(compooper.EtapeTreeItem):
pass
return args
- def get_corps(self):
+ def getCorps(self):
"""
Retourne le corps de la FORMULE
"""
@@ -139,14 +139,14 @@ class FORMULETreeItem(compooper.EtapeTreeItem):
return corps
- def get_liste_types_autorises(self):
+ def getListeTypesAutorises(self):
"""
Retourne la liste des types autorises pour les valeurs de sortie
d'une FORMULE
"""
return self.object.l_types_autorises
- def save_formule(self,new_nom,new_typ,new_arg,new_exp):
+ def saveFormule(self,new_nom,new_typ,new_arg,new_exp):
"""
Verifie si (new_nom,new_typ,new_arg,new_exp) definit bien une FORMULE
licite :
@@ -155,7 +155,7 @@ class FORMULETreeItem(compooper.EtapeTreeItem):
- si non, laisse les parametres anciens de la FORMULE inchanges et
retourne 0
"""
- test,erreur = self.object.verif_formule_python(formule=(new_nom,new_typ,new_arg,
+ test,erreur = self.object.verifFormule_python(formule=(new_nom,new_typ,new_arg,
new_exp))
if test :
# la formule est bien correcte : on sauve les nouveaux parametres
@@ -166,30 +166,30 @@ class FORMULETreeItem(compooper.EtapeTreeItem):
# Acces aux methodes de verification de l'objet FORM_ETAPE
# ---------------------------------------------------------------------------
- def verif_nom(self,nom):
+ def verifNom(self,nom):
"""
Lance la verification du nom passe en argument
"""
- return self.object.verif_nom(nom)
+ return self.object.verifNom(nom)
- def verif_arguments(self,arguments):
+ def verifArguments(self,arguments):
"""
Lance la verification des arguments passes en argument
"""
- return self.object.verif_arguments('('+arguments+')')
+ return self.object.verifArguments('('+arguments+')')
- def verif_formule(self,formule):
+ def verifFormule(self,formule):
"""
Lance la verification de FORMULE passee en argument
"""
- return self.object.verif_formule(formule=formule)
+ return self.object.verifFormule(formule=formule)
- def verif_formule_python(self,formule):
+ def verifFormule_python(self,formule):
"""
Lance la verification de FORMULE passee en argument
"""
- return self.object.verif_formule_python(formule=formule)
+ return self.object.verifFormule_python(formule=formule)
import Accas
treeitem =FORMULETreeItem
diff --git a/InterfaceQT4/compojdc.py b/InterfaceQT4/compojdc.py
index fd95201a..111a4e98 100644
--- a/InterfaceQT4/compojdc.py
+++ b/InterfaceQT4/compojdc.py
@@ -36,7 +36,7 @@ class Node(browser.JDCNode,typeNode.PopUpMenuRacine):
typeNode.PopUpMenuRacine.createPopUpMenu(self)
def addParameters(self,apres):
- param=self.append_child("PARAMETRE",pos=0)
+ param=self.appendChild("PARAMETRE",pos=0)
return param
@@ -44,24 +44,24 @@ class Node(browser.JDCNode,typeNode.PopUpMenuRacine):
class JDCTreeItem(Objecttreeitem.ObjectTreeItem):
itemNode=Node
- def IsExpandable(self):
+ def isExpandable(self):
return 1
- def GetText(self):
+ def getText(self):
return " "
- def GetLabelText(self):
+ def getLabelText(self):
# None --> fonte et couleur par defaut
return tr(self.object.nom),None,None
- def get_jdc(self):
+ def getJdc(self):
"""
Retourne l'objet pointe par self
"""
return self.object
- def GetIconName(self):
- if self.object.isvalid():
+ def getIconName(self):
+ if self.object.isValid():
return "ast-green-square"
else:
return "ast-red-square"
@@ -72,17 +72,17 @@ class JDCTreeItem(Objecttreeitem.ObjectTreeItem):
# else:
# return range(len(self.object.etapes))
- def additem(self,name,pos):
- cmd = self._object.addentite(name,pos)
+ def addItem(self,name,pos):
+ cmd = self._object.addEntite(name,pos)
return cmd
- def suppitem(self,item) :
+ def suppItem(self,item) :
# item = item de l'ETAPE a supprimer du JDC
# item.getObject() = ETAPE ou COMMENTAIRE
# self.object = JDC
itemobject=item.getObject()
- if self.object.suppentite(itemobject):
+ if self.object.suppEntite(itemobject):
if itemobject.nature == "COMMENTAIRE" :
message = tr("Commentaire supprime")
else :
@@ -92,7 +92,7 @@ class JDCTreeItem(Objecttreeitem.ObjectTreeItem):
message=tr("Pb interne : impossible de supprimer cet objet")
return 0,message
- def GetSubList(self):
+ def getSubList(self):
"""
Retourne la liste des items fils de l'item jdc.
Cette liste est conservee et mise a jour a chaque appel
@@ -115,19 +115,19 @@ class JDCTreeItem(Objecttreeitem.ObjectTreeItem):
for obj in liste:
if sublist[pos] is None:
# nouvel objet : on cree un nouvel item
- item = self.make_objecttreeitem(self.appli, obj.nom + " : ", obj)
+ item = self.makeObjecttreeitem(self.appli, obj.nom + " : ", obj)
sublist[pos]=item
pos=pos+1
self.sublist=sublist
return self.sublist
- def get_l_noms_etapes(self):
+ def getLNomsEtapes(self):
""" Retourne la liste des noms des etapes de self.object"""
- return self.object.get_l_noms_etapes()
+ return self.object.getLNomsEtapes()
- def get_liste_cmd(self):
- listeCmd = self.object.niveau.definition.get_liste_cmd()
+ def getListeCmd(self):
+ listeCmd = self.object.niveau.definition.getListeCmd()
return listeCmd
import Accas
diff --git a/InterfaceQT4/compomacro.py b/InterfaceQT4/compomacro.py
index f597a98f..85f45625 100644
--- a/InterfaceQT4/compomacro.py
+++ b/InterfaceQT4/compomacro.py
@@ -44,12 +44,12 @@ class MACRONode(browser.JDCNode,typeNode.PopUpMenuNode):
def createPopUpMenu(self):
typeNode.PopUpMenuNode.createPopUpMenu(self)
- if ("AFFE_CARA_ELEM" in self.item.get_genealogie()) and self.editor.salome:
+ if ("AFFE_CARA_ELEM" in self.item.getGenealogie()) and self.editor.salome:
self.ViewElt = QAction(tr('View3D'),self.tree)
self.ViewElt.triggered.connect(self.view3D)
self.ViewElt.setStatusTip(tr("affiche dans Geom les elements de structure"))
self.menu.addAction(self.ViewElt)
- if self.item.isvalid() :
+ if self.item.isValid() :
self.ViewElt.setEnabled(1)
else:
self.ViewElt.setEnabled(0)
@@ -73,10 +73,10 @@ class MACROTreeItem(compooper.EtapeTreeItem):
class INCLUDETreeItemBase(MACROTreeItem):
- def __init__(self,appli, labeltext, object, setfunction):
- MACROTreeItem.__init__(self,appli, labeltext, object, setfunction)
+ def __init__(self,appli, labeltext, object, setFunction):
+ MACROTreeItem.__init__(self,appli, labeltext, object, setFunction)
- def iscopiable(self):
+ def isCopiable(self):
return 0
@@ -174,18 +174,18 @@ class INCLUDE_MATERIAUTreeItem(INCLUDETreeItemBase):
# ------------------------------------
-def treeitem(appli, labeltext, object, setfunction=None):
+def treeitem(appli, labeltext, object, setFunction=None):
""" Factory qui retourne l'item adapte au type de macro :
INCLUDE, POURSUITE, MACRO
"""
if object.nom == "INCLUDE_MATERIAU":
- return INCLUDE_MATERIAUTreeItem(appli, labeltext, object, setfunction)
+ return INCLUDE_MATERIAUTreeItem(appli, labeltext, object, setFunction)
elif object.nom == "INCLUDE" or object.nom== "DICTDATA":
- return INCLUDETreeItem(appli, labeltext, object, setfunction)
+ return INCLUDETreeItem(appli, labeltext, object, setFunction)
elif object.nom == "POURSUITE":
- return POURSUITETreeItem(appli, labeltext, object, setfunction)
+ return POURSUITETreeItem(appli, labeltext, object, setFunction)
else:
- return MACROTreeItem(appli, labeltext, object, setfunction)
+ return MACROTreeItem(appli, labeltext, object, setFunction)
import Accas
objet=Accas.MACRO_ETAPE
diff --git a/InterfaceQT4/compomclist.py b/InterfaceQT4/compomclist.py
index 6b8a7d4d..93905264 100644
--- a/InterfaceQT4/compomclist.py
+++ b/InterfaceQT4/compomclist.py
@@ -59,12 +59,12 @@ class Node(browser.JDCNode,typeNode.PopUpMenuNodeMinimal):
def doPaste(self,node_selected,pos):
- objet_a_copier = self.item.get_copie_objet()
+ objet_a_copier = self.item.getCopieObjet()
# before est un effet de bord heureux sur l index
child=self.appendBrother(objet_a_copier,'before')
if self.editor.fenetreCentraleAffichee : self.editor.fenetreCentraleAffichee.node.affichePanneau()
- self.update_node_label_in_black()
- self.parent().build_children()
+ self.update_NodeLabelInBlack()
+ self.parent().buildChildren()
return child
@@ -83,6 +83,9 @@ class MCListTreeItem(Objecttreeitem.SequenceTreeItem,compofact.FACTTreeItem):
def init(self):
# Si l'objet Accas (MCList) a moins d'un mot cle facteur
# on utilise directement ce mot cle facteur comme delegue
+ #print ('he suis dans init de MCListTreeItem')
+ #import traceback
+ #traceback.print_stack()
self.updateDelegate()
def updateDelegate(self):
@@ -97,6 +100,7 @@ class MCListTreeItem(Objecttreeitem.SequenceTreeItem,compofact.FACTTreeItem):
FACTPanel.
Si la liste est plus longue on utilise le panneau MCLISTPanel.
"""
+ print ('he suis dans panel de MCListTreeItem')
if len(self._object) > 1:
return MCLISTPanel(jdcdisplay,pane,node)
elif isinstance(self._object.data[0],ErrorObj):
@@ -104,17 +108,17 @@ class MCListTreeItem(Objecttreeitem.SequenceTreeItem,compofact.FACTTreeItem):
else:
return compofact.FACTPanel(jdcdisplay,pane,node)
- def IsExpandable(self):
+ def isExpandable(self):
if len(self._object) > 1:
- return Objecttreeitem.SequenceTreeItem.IsExpandable(self)
+ return Objecttreeitem.SequenceTreeItem.isExpandable(self)
else:
- return compofact.FACTTreeItem.IsExpandable(self)
+ return compofact.FACTTreeItem.isExpandable(self)
- def GetSubList(self):
+ def getSubList(self):
self.updateDelegate()
if len(self._object) <= 1:
self._object.data[0].alt_parent=self._object
- return compofact.FACTTreeItem.GetSubList(self)
+ return compofact.FACTTreeItem.getSubList(self)
liste=self._object.data
sublist=[None]*len(liste)
@@ -131,9 +135,9 @@ class MCListTreeItem(Objecttreeitem.SequenceTreeItem,compofact.FACTTreeItem):
for obj in liste:
if sublist[pos] is None:
# nouvel objet : on cree un nouvel item
- def setfunction(value, object=obj):
+ def setFunction(value, object=obj):
object=value
- item = self.make_objecttreeitem(self.appli, obj.nom + " : ", obj, setfunction)
+ item = self.makeObjecttreeitem(self.appli, obj.nom + " : ", obj, setFunction)
sublist[pos]=item
#Attention : on ajoute une information supplementaire pour l'actualisation de
# la validite. L'attribut parent d'un MCFACT pointe sur le parent de la MCLISTE
@@ -145,23 +149,23 @@ class MCListTreeItem(Objecttreeitem.SequenceTreeItem,compofact.FACTTreeItem):
self.sublist=sublist
return self.sublist
- def GetIconName(self):
- if self._object.isvalid():
+ def getIconName(self):
+ if self._object.isValid():
return "ast-green-los"
- elif self._object.isoblig():
+ elif self._object.isOblig():
return "ast-red-los"
else:
return "ast-yel-los"
- def get_docu(self):
+ def getDocu(self):
""" Retourne la clef de doc de l'objet pointe par self """
- return self.object.get_docu()
+ return self.object.getDocu()
- def iscopiable(self):
+ def isCopiable(self):
if len(self._object) > 1:
- return Objecttreeitem.SequenceTreeItem.iscopiable(self)
+ return Objecttreeitem.SequenceTreeItem.isCopiable(self)
else:
- return compofact.FACTTreeItem.iscopiable(self)
+ return compofact.FACTTreeItem.isCopiable(self)
def isMCFact(self):
"""
@@ -175,30 +179,29 @@ class MCListTreeItem(Objecttreeitem.SequenceTreeItem,compofact.FACTTreeItem):
"""
return len(self._object) > 1
- def get_copie_objet(self):
+ def getCopieObjet(self):
return self._object.data[0].copy()
- def additem(self,obj,pos):
- #print "compomclist.additem",obj,pos
+ def addItem(self,obj,pos):
+ #print "compomclist.addItem",obj,pos
if len(self._object) <= 1:
- return compofact.FACTTreeItem.additem(self,obj,pos)
+ return compofact.FACTTreeItem.addItem(self,obj,pos)
- o= self.object.addentite(obj,pos)
+ o= self.object.addEntite(obj,pos)
return o
- def suppitem(self,item):
+ def suppItem(self,item):
"""
Retire un objet MCFACT de la MCList (self.object)
"""
- #print "compomclist.suppitem",item
+ #print "compomclist.suppItem",item
obj=item.getObject()
if len(self._object) <= 1:
- return compofact.FACTTreeItem.suppitem(self,item)
+ return compofact.FACTTreeItem.suppItem(self,item)
- if self.object.suppentite(obj):
+ if self.object.suppEntite(obj):
if len(self._object) == 1: self.updateDelegate()
message = "Mot-clef " + obj.nom + " supprime"
- #self.editor.affiche_commentaire(message)
return (1,message)
else:
return (0,tr('Impossible de supprimer ce mot-clef'))
@@ -207,8 +210,8 @@ class MCListTreeItem(Objecttreeitem.SequenceTreeItem,compofact.FACTTreeItem):
import Accas
objet = Accas.MCList
-def treeitem(appli,labeltext,object,setfunction):
+def treeitem(appli,labeltext,object,setFunction):
""" Factory qui produit un objet treeitem adapte a un objet
Accas.MCList (attribut objet de ce module)
"""
- return MCListTreeItem(appli,labeltext,object,setfunction)
+ return MCListTreeItem(appli,labeltext,object,setFunction)
diff --git a/InterfaceQT4/compooper.py b/InterfaceQT4/compooper.py
index bbf7db34..7a8209d1 100644
--- a/InterfaceQT4/compooper.py
+++ b/InterfaceQT4/compooper.py
@@ -43,19 +43,19 @@ class Node(browser.JDCNode, typeNode.PopUpMenuNode):
self.treeParent.tree.openPersistentEditor(self,1)
self.monWidgetNom=self.treeParent.tree.itemWidget(self,1)
self.monWidgetNom.returnPressed.connect(self.nomme)
- if self.item.GetIconName() == "ast-red-square" : self.monWidgetNom.setDisabled(True)
+ if self.item.getIconName() == "ast-red-square" : self.monWidgetNom.setDisabled(True)
#else : self.monWidgetNom.setFocus() ;self.monWidgetNom.setDisabled(False)
def nomme(self):
nom=str(self.monWidgetNom.text())
- self.editor.init_modif()
- test,mess = self.item.nomme_sd(nom)
+ self.editor.initModif()
+ test,mess = self.item.nommeSd(nom)
if (test== 0):
- self.editor.affiche_infos(mess,Qt.red)
- old=self.item.GetText()
+ self.editor.afficheInfos(mess,Qt.red)
+ old=self.item.getText()
self.monWidgetNom.setText(old)
else :
- self.editor.affiche_commentaire(tr("Nommage du concept effectue"))
+ self.editor.afficheCommentaire(tr("Nommage du concept effectue"))
self.onValid()
try :
self.fenetre.LENom.setText(nom)
@@ -69,21 +69,21 @@ class Node(browser.JDCNode, typeNode.PopUpMenuNode):
def createPopUpMenu(self):
typeNode.PopUpMenuNode.createPopUpMenu(self)
- if ("AFFE_CARA_ELEM" in self.item.get_genealogie()) and self.editor.salome:
+ if ("AFFE_CARA_ELEM" in self.item.getGenealogie()) and self.editor.salome:
self.ViewElt = QAction(tr('View3D'),self.tree)
self.tree.connect(self.ViewElt,SIGNAL("triggered()"),self.view3D)
self.ViewElt.setStatusTip(tr("affiche dans Geom les elements de structure"))
self.menu.addAction(self.ViewElt)
- if self.item.isvalid() :
+ if self.item.isValid() :
self.ViewElt.setEnabled(1)
else:
self.ViewElt.setEnabled(0)
- if self.item.get_nom() == "DISTRIBUTION" :
+ if self.item.getNom() == "DISTRIBUTION" :
self.Graphe = QAction(tr('Graphique'),self.tree)
self.Graphe.triggered.connect(self.viewPng)
self.Graphe.setStatusTip(tr("affiche la distribution "))
self.menu.addAction(self.Graphe)
- if self.item.isvalid() :
+ if self.item.isValid() :
self.Graphe.setEnabled(1)
else:
self.Graphe.setEnabled(0)
@@ -136,17 +136,17 @@ class EtapeTreeItem(Objecttreeitem.ObjectTreeItem):
"""
itemNode=Node
- def IsExpandable(self):
+ def isExpandable(self):
return 1
- def GetIconName(self):
+ def getIconName(self):
"""
Retourne le nom de l'icone a afficher dans l'arbre
Ce nom depend de la validite de l'objet
"""
- if not self.object.isactif():
+ if not self.object.isActif():
return "ast-white-square"
- elif self.object.isvalid():
+ elif self.object.isValid():
return "ast-green-square"
else:
valid=self.valid_child()
@@ -165,55 +165,52 @@ class EtapeTreeItem(Objecttreeitem.ObjectTreeItem):
pass
return "ast-yellow-square"
- def GetLabelText(self):
+ def getLabelText(self):
""" Retourne 3 valeurs :
- le texte a afficher dans le noeud représentant l'item
- la fonte dans laquelle afficher ce texte
- la couleur du texte
"""
return self.labeltext,None,None
- #if self.object.isactif():
+ #if self.object.isActif():
# None --> fonte et couleur par défaut
# return self.labeltext,None,None
#else:
# return self.labeltext, None, None #CS_pbruno todo
- def get_objet(self,name) :
- for v in self.object.mc_liste:
- if v.nom == name : return v
- return None
+ #def get_objet(self,name) :
+ # for v in self.object.mc_liste:
+ # if v.nom == name : return v
+ # return None
- def get_type_sd_prod(self):
+ def getType_sd_prod(self):
"""
Retourne le nom du type du concept résultat de l'étape
"""
- sd_prod=self.object.get_type_produit()
+ sd_prod=self.object.getType_produit()
if sd_prod:
return sd_prod.__name__
else:
return ""
- def additem(self,name,pos):
- mcent = self._object.addentite(name,pos)
+ def addItem(self,name,pos):
+ mcent = self._object.addEntite(name,pos)
return mcent
- def suppitem(self,item) :
+ def suppItem(self,item) :
# item : item du MOCLE de l'ETAPE a supprimer
# item.getObject() = MCSIMP, MCFACT, MCBLOC ou MCList
itemobject=item.getObject()
- if itemobject.isoblig() :
- #self.editor.affiche_infos(tr('Impossible de supprimer un mot-clef obligatoire '),Qt.red)
+ if itemobject.isOblig() :
return (0,tr('Impossible de supprimer un mot-clef obligatoire '))
- if self.object.suppentite(itemobject):
+ if self.object.suppEntite(itemobject):
message = tr("Mot-clef %s supprime " , itemobject.nom)
- #self.editor.affiche_commentaire(message)
return (1,message)
else :
- #self.editor.affiche_commentaire(tr('Pb interne : impossible de supprimer ce mot-clef'),Qt.red)
return (0,tr('Pb interne : impossible de supprimer ce mot-clef'))
- def GetText(self):
+ def getText(self):
try:
return self.object.get_sdname()
except:
@@ -224,11 +221,11 @@ class EtapeTreeItem(Objecttreeitem.ObjectTreeItem):
# keys=self.object.mc_dict
# return keys
- def GetSubList(self):
+ def getSubList(self):
"""
Reactualise la liste des items fils stockes dans self.sublist
"""
- if self.isactif():
+ if self.isActif():
liste=self.object.mc_liste
else:
liste=[]
@@ -248,19 +245,19 @@ class EtapeTreeItem(Objecttreeitem.ObjectTreeItem):
for obj in liste:
if sublist[pos] is None:
# nouvel objet : on cree un nouvel item
- def setfunction(value, object=obj):
+ def setFunction(value, object=obj):
object.setval(value)
- item = self.make_objecttreeitem(self.appli, obj.nom + " : ", obj, setfunction)
+ item = self.makeObjecttreeitem(self.appli, obj.nom + " : ", obj, setFunction)
sublist[pos]=item
pos=pos+1
self.sublist=sublist
return self.sublist
- def isvalid(self):
- return self.object.isvalid()
+ def isValid(self):
+ return self.object.isValid()
- def iscopiable(self):
+ def isCopiable(self):
"""
Retourne 1 si l'objet est copiable, 0 sinon
"""
@@ -273,35 +270,35 @@ class EtapeTreeItem(Objecttreeitem.ObjectTreeItem):
def update(self,item):
if item.sd and item.sd.nom:
- self.nomme_sd(item.sd.nom)
+ self.nommeSd(item.sd.nom)
- def nomme_sd(self,nom):
+ def nommeSd(self,nom):
""" Lance la méthode de nommage de la SD """
oldnom=""
if self.object.sd != None :
oldnom=self.object.sd.nom
- test,mess= self.object.nomme_sd(nom)
- if test:self.object.parent.reset_context()
+ test,mess= self.object.nommeSd(nom)
+ if test:self.object.parent.resetContext()
if (test and oldnom in self.appli.dict_reels ):
self.appli.dict_reels[nom]=self.appli.dict_reels[oldnom]
return test,mess
- def is_reentrant(self):
- return self.object.is_reentrant()
+ def isReentrant(self):
+ return self.object.isReentrant()
- def get_noms_sd_oper_reentrant(self):
- return self.object.get_noms_sd_oper_reentrant()
+ def getNomsSdOperReentrant(self):
+ return self.object.getNomsSdOperReentrant()
- def get_objet_commentarise(self):
+ def getObjetCommentarise(self):
"""
Cette méthode retourne un objet commentarisé
représentatif de self.object
"""
# Format de fichier utilisé
format=self.appli.appliEficas.format_fichier
- return self.object.get_objet_commentarise(format)
+ return self.object.getObjetCommentarise(format)
- def get_objet_commentarise_BAK(self):
+ def getObjetCommentarise_BAK(self):
"""
Cette méthode retourne un objet commentarisé
représentatif de self.object
@@ -323,8 +320,8 @@ class EtapeTreeItem(Objecttreeitem.ObjectTreeItem):
pos=self.object.parent.etapes.index(self.object)
parent=self.object.parent
- self.object.parent.suppentite(self.object)
- parent.addentite(commande_comment,pos)
+ self.object.parent.suppEntite(self.object)
+ parent.addEntite(commande_comment,pos)
return commande_comment
diff --git a/InterfaceQT4/compoparam.py b/InterfaceQT4/compoparam.py
index ed2bd7a9..8b55d13f 100644
--- a/InterfaceQT4/compoparam.py
+++ b/InterfaceQT4/compoparam.py
@@ -62,27 +62,27 @@ class PARAMTreeItem(Objecttreeitem.ObjectTreeItem):
itemNode=Node
def init(self):
- self.setfunction = self.set_valeur
+ self.setFunction = self.setValeur
# ---------------------------------------------------------------------------
# API du PARAMETRE pour l'arbre
# ---------------------------------------------------------------------------
- def GetIconName(self):
+ def getIconName(self):
"""
Retourne le nom de l'icone associee au noeud qui porte self,
dependant de la validite de l'objet
NB : un PARAMETRE est toujours valide ...
"""
- if self.isactif():
- if self.isvalid():
+ if self.isActif():
+ if self.isValid():
return "ast-green-square"
else:
return "ast-red-square"
else:
return "ast-white-square"
- def GetLabelText(self):
+ def getLabelText(self):
""" Retourne 3 valeurs :
- le texte a afficher dans le noeud representant l'item
- la fonte dans laquelle afficher ce texte
@@ -90,7 +90,7 @@ class PARAMTreeItem(Objecttreeitem.ObjectTreeItem):
"""
return tr('PARAMETRE'),None,None
- def GetText(self):
+ def getText(self):
"""
Retourne le texte a afficher apres le nom de la commande (ici apres 'parametre')
Ce texte est tronque a 25 caracteres
@@ -107,7 +107,7 @@ class PARAMTreeItem(Objecttreeitem.ObjectTreeItem):
else :
return texte[0:24]+'...'
- def GetSubList(self):
+ def getSubList(self):
"""
Retourne la liste des fils de self
"""
@@ -118,33 +118,33 @@ class PARAMTreeItem(Objecttreeitem.ObjectTreeItem):
# du parametre = API graphique du PARAMETRE pour Panel et EFICAS
# ---------------------------------------------------------------------------
- def get_valeur(self):
+ def getValeur(self):
"""
Retourne la valeur de l'objet PARAMETRE cad son texte
"""
if self.object.valeur is None: return ''
else: return self.object.valeur
- def get_nom(self):
+ def getNom(self):
"""
Retourne le nom du parametre
"""
return self.object.nom
- def set_valeur(self,new_valeur):
+ def setValeur(self,new_valeur):
"""
Affecte valeur a l'objet PARAMETRE
"""
- self.object.set_valeur(new_valeur)
+ self.object.setValeur(new_valeur)
- def set_nom(self,new_nom):
+ def setNom(self,new_nom):
"""
Renomme le parametre
"""
- self.object.set_nom(new_nom)
+ self.object.setNom(new_nom)
#self.object.set_attribut('nom',new_nom)
- def get_fr(self):
+ def getFr(self):
"""
Retourne le fr associe au parametre, cad la bulle d'aide pour EFICAS
"""
diff --git a/InterfaceQT4/composimp.py b/InterfaceQT4/composimp.py
index b46ceb36..2a990edc 100644
--- a/InterfaceQT4/composimp.py
+++ b/InterfaceQT4/composimp.py
@@ -59,14 +59,14 @@ class Node(browser.JDCNode,typeNode.PopUpMenuNodeMinimal):
# Attention il faut gerer les blocs et les facteurs
# a gerer comme dans composimp
# Gestion des matrices
- if self.item.wait_matrice ():
+ if self.item.waitMatrice ():
from .monWidgetMatrice import MonWidgetMatrice
widget=MonWidgetMatrice(self,maDefinition,monNom,monObjet,parentQt,maCommande)
self.widget=widget
return widget
- #print "____________________________", monNom, self.item.wait_co()
- #print "____________________________", monNom, self.item.wait_assd()
+ #print "____________________________", monNom, self.item.waitCo()
+ #print "____________________________", monNom, self.item.waitAssd()
# Gestion d'une seule valeur (eventuellement un tuple ou un complexe)
if maDefinition.into != [] and maDefinition.into != None:
if type(maDefinition.into) ==types.FunctionType : monInto=maDefinition.into()
@@ -76,7 +76,10 @@ class Node(browser.JDCNode,typeNode.PopUpMenuNodeMinimal):
if maDefinition.max == 1 :
# A verifier
- if maDefinition.into != [] and maDefinition.into != None:
+ if maDefinition.intoSug != [] and maDefinition.intoSug != None:
+ from .monWidgetCBIntoSug import MonWidgetCBIntoSug
+ widget=MonWidgetCBIntoSug(self,maDefinition,monNom,monObjet,parentQt,maCommande)
+ elif maDefinition.into != [] and maDefinition.into != None:
if len(monInto) < 4 :
from .monWidgetRadioButton import MonWidgetRadioButton
widget=MonWidgetRadioButton(self,maDefinition,monNom,monObjet,parentQt,maCommande)
@@ -87,22 +90,22 @@ class Node(browser.JDCNode,typeNode.PopUpMenuNodeMinimal):
from .monWidgetCB import MonWidgetCB
widget=MonWidgetCB(self,maDefinition,monNom,monObjet,parentQt,maCommande)
- elif self.item.wait_bool() :
+ elif self.item.waitBool() :
from .monWidgetSimpBool import MonWidgetSimpBool
widget=MonWidgetSimpBool(self,maDefinition,monNom,monObjet,parentQt,maCommande)
- elif self.item.wait_fichier():
+ elif self.item.waitFichier():
from .monWidgetSimpFichier import MonWidgetSimpFichier
widget=MonWidgetSimpFichier(self,maDefinition,monNom,monObjet,parentQt,maCommande)
# PNPNPN - a faire
- elif self.item.wait_date():
+ elif self.item.waitDate():
from .monWidgetDate import MonWidgetDate
widget=MonWidgetDate(self,maDefinition,monNom,monObjet,parentQt,maCommande)
- elif self.item.wait_heure():
+ elif self.item.waitHeure():
from .monWidgetHeure import MonWidgetHeure
widget=MonWidgetHeure(self,maDefinition,monNom,monObjet,parentQt,maCommande)
- elif self.item.wait_tuple() :
+ elif self.item.waitTuple() :
if self.item.object.definition.type[0].ntuple == 2:
from .monWidgetSimpTuple2 import MonWidgetSimpTuple2
widget=MonWidgetSimpTuple2(self,maDefinition,monNom,monObjet,parentQt,maCommande)
@@ -113,36 +116,36 @@ class Node(browser.JDCNode,typeNode.PopUpMenuNodeMinimal):
print ("Pas de Tuple de longueur > 3")
print ("Prevenir la maintenance ")
- elif self.item.wait_complex():
+ elif self.item.waitComplex():
from .monWidgetSimpComplexe import MonWidgetSimpComplexe
widget=MonWidgetSimpComplexe(self,maDefinition,monNom,monObjet,parentQt,maCommande)
- elif self.item.wait_co():
- if len(self.item.get_sd_avant_du_bon_type()) == 0 :
+ elif self.item.waitCo():
+ if len(self.item.getSdAvantDuBonType()) == 0 :
from .monWidgetUniqueSDCO import MonWidgetUniqueSDCO
widget=MonWidgetUniqueSDCO(self,maDefinition,monNom,monObjet,parentQt,maCommande)
else :
from .monWidgetSDCOInto import MonWidgetSDCOInto
widget=MonWidgetSDCOInto(self,maDefinition,monNom,monObjet,parentQt,maCommande)
- elif self.item.wait_assd():
- if len(self.item.get_sd_avant_du_bon_type()) == 0 :
+ elif self.item.waitAssd():
+ if len(self.item.getSdAvantDuBonType()) == 0 :
from .monWidgetVide import MonWidgetVide
widget=MonWidgetVide(self,maDefinition,monNom,monObjet,parentQt,maCommande)
- elif len(self.item.get_sd_avant_du_bon_type()) < 4 :
+ elif len(self.item.getSdAvantDuBonType()) < 4 :
from .monWidgetRadioButton import MonWidgetRadioButtonSD
widget=MonWidgetRadioButtonSD(self,maDefinition,monNom,monObjet,parentQt,maCommande)
- elif len(self.item.get_sd_avant_du_bon_type()) < 7 :
+ elif len(self.item.getSdAvantDuBonType()) < 7 :
from .monWidget4a6RadioButton import MonWidget4a6RadioButtonSD
widget=MonWidget4a6RadioButtonSD(self,maDefinition,monNom,monObjet,parentQt,maCommande)
else :
from .monWidgetCB import MonWidgetCBSD
widget=MonWidgetCBSD(self,maDefinition,monNom,monObjet,parentQt,maCommande)
- elif self.item.wait_Salome() and self.editor.salome:
+ elif self.item.waitSalome() and self.editor.salome:
from .monWidgetSimpSalome import MonWidgetSimpSalome
widget=MonWidgetSimpSalome(self,maDefinition,monNom,monObjet,parentQt,maCommande)
- elif self.item.wait_TXM():
+ elif self.item.waitTxm():
from .monWidgetSimpTxt import MonWidgetSimpTxt
widget=MonWidgetSimpTxt(self,maDefinition,monNom,monObjet,parentQt,maCommande)
else :
@@ -160,21 +163,16 @@ class Node(browser.JDCNode,typeNode.PopUpMenuNodeMinimal):
widget=MonWidgetPlusieursPlie(self,maDefinition,monNom,monObjet,parentQt,maCommande)
#if maDefinition.into != [] and maDefinition.into != None:
# Attention pas fini --> on attend une liste de ASSD avec ordre
- elif self.item.wait_assd() and self.item.is_list_SansOrdreNiDoublon():
- #if self.item.is_list_Chargement():
- #from monWidgetPlusieursTuple2AvecChargement import MonWidgetPlusieursTuple2AvecChargement
- #widget=MonWidgetPlusieursTuple2(self,maDefinition,monNom,monObjet,parentQt,maCommande)
- # pass
- #else :
- listeAAfficher = self.item.get_sd_avant_du_bon_type()
+ elif self.item.waitAssd() and self.item.isListSansOrdreNiDoublon():
+ listeAAfficher = self.item.getSdAvantDuBonType()
if len(listeAAfficher) == 0:
from .monWidgetVide import MonWidgetVide
widget = MonWidgetVide(self,maDefinition,monNom,monObjet,parentQt,maCommande)
else :
from .monWidgetPlusieursInto import MonWidgetPlusieursInto
widget=MonWidgetPlusieursInto(self,maDefinition,monNom,monObjet,parentQt,maCommande)
- elif self.item.wait_assd() :
- listeAAfficher = self.item.get_sd_avant_du_bon_type()
+ elif self.item.waitAssd() :
+ listeAAfficher = self.item.getSdAvantDuBonType()
if len(listeAAfficher) == 0:
from .monWidgetVide import MonWidgetVide
widget = MonWidgetVide(self,maDefinition,monNom,monObjet,parentQt,maCommande)
@@ -184,7 +182,7 @@ class Node(browser.JDCNode,typeNode.PopUpMenuNodeMinimal):
else :
from .monWidgetPlusieursPlie import MonWidgetPlusieursPlieASSD
widget=MonWidgetPlusieursPlieASSD(self,maDefinition,monNom,monObjet,parentQt,maCommande)
- elif self.item.wait_tuple() :
+ elif self.item.waitTuple() :
if self.item.object.definition.type[0].ntuple == 2:
from .monWidgetPlusieursTuple2 import MonWidgetPlusieursTuple2
widget=MonWidgetPlusieursTuple2(self,maDefinition,monNom,monObjet,parentQt,maCommande)
@@ -194,8 +192,8 @@ class Node(browser.JDCNode,typeNode.PopUpMenuNodeMinimal):
else :
print ("Pas de Tuple de longueur > 3")
print ("Prevenir la maintenance ")
- elif self.item.has_into():
- if self.item.is_list_SansOrdreNiDoublon():
+ elif self.item.hasInto():
+ if self.item.isListSansOrdreNiDoublon():
if self.item in self.editor.listeDesListesOuvertes or not(self.editor.afficheListesPliees) :
from .monWidgetPlusieursInto import MonWidgetPlusieursInto
@@ -236,17 +234,15 @@ class SIMPTreeItem(Objecttreeitem.AtomicObjectTreeItem):
# ou au mot-clef simple
#
#-----------------------------------------------
- # is_list
- # get_into a priori inutile --> commentee
- # has_into
- # wait_into a priori inutile --> commentee
- # GetMinMax
- # GetMultiplicite
- # GetIntervalle
- # GetListeValeurs
- # get_liste_possible
-
- def is_list(self):
+ # isList
+ # hasInto
+ # getMinMax
+ # getMultiplicite
+ # getIntervalle
+ # getListeValeurs
+ # getListePossible
+
+ def isList(self):
"""
Cette methode indique si le mot cle simple attend une liste (valeur de retour 1)
ou s'il n'en attend pas (valeur de retour 0)
@@ -255,31 +251,28 @@ class SIMPTreeItem(Objecttreeitem.AtomicObjectTreeItem):
Dans le cas sans validateur, l'information est donnee par l'attribut max
de la definition du mot cle.
Dans le cas avec validateur, il faut combiner l'information precedente avec
- celle issue de l'appel de la methode is_list sur le validateur.On utilisera
+ celle issue de l'appel de la methode isList sur le validateur.On utilisera
l'operateur ET pour effectuer cette combinaison (AndVal).
"""
is_a_list=0
- min,max = self.GetMinMax()
+ min,max = self.getMinMax()
assert (min <= max)
if max > 1 :
is_a_list=1
# Dans le cas avec validateurs, pour que le mot cle soit considere
# comme acceptant une liste, il faut que max soit superieur a 1
- # ET que la methode is_list du validateur retourne 1. Dans les autres cas
+ # ET que la methode isList du validateur retourne 1. Dans les autres cas
# on retournera 0 (n'attend pas de liste)
if self.definition.validators :
- is_a_list= self.definition.validators.is_list() * is_a_list
+ is_a_list= self.definition.validators.isList() * is_a_list
return is_a_list
- def is_list_SansOrdreNiDoublon(self):
+ def isListSansOrdreNiDoublon(self):
if self.definition.homo=="SansOrdreNiDoublon" : return 1
return 0
- def is_list_Chargement(self):
- if self.definition.docu != "" : return 1
- return 0
- def has_into(self):
+ def hasInto(self):
"""
Cette methode indique si le mot cle simple propose un choix (valeur de retour 1)
ou s'il n'en propose pas (valeur de retour 0)
@@ -289,40 +282,40 @@ class SIMPTreeItem(Objecttreeitem.AtomicObjectTreeItem):
de la definition du mot cle.
Dans le cas avec validateurs, pour que le mot cle soit considere
comme proposant un choix, il faut que into soit present OU
- que la methode has_into du validateur retourne 1. Dans les autres cas
+ que la methode hasInto du validateur retourne 1. Dans les autres cas
on retournera 0 (ne propose pas de choix)
"""
has_an_into=0
if self.definition.into:
has_an_into=1
elif self.definition.validators :
- has_an_into= self.definition.validators.has_into()
+ has_an_into= self.definition.validators.hasInto()
return has_an_into
- def has_intoSug(self):
+ def hasIntoSug(self):
if self.definition.intoSug: return 1
return 0
- def GetMinMax(self):
+ def getMinMax(self):
""" Retourne les valeurs min et max de la definition de object """
return self.object.get_min_max()
- def GetMultiplicite(self):
+ def getMultiplicite(self):
""" A preciser.
Retourne la multiplicite des valeurs affectees a l'objet
represente par l'item. Pour le moment retourne invariablement 1.
"""
return 1
- def GetIntervalle(self):
+ def getIntervalle(self):
"""
Retourne le domaine de valeur attendu par l'objet represente
par l'item.
"""
return self.object.getintervalle()
- def GetListeValeurs(self) :
+ def getListeValeurs(self) :
""" Retourne la liste des valeurs de object """
valeurs=self.object.get_liste_valeurs()
try :
@@ -344,7 +337,7 @@ class SIMPTreeItem(Objecttreeitem.AtomicObjectTreeItem):
pass
return valeurs
- def get_liste_possible(self,listeActuelle=[]):
+ def getListePossible(self,listeActuelle=[]):
if hasattr(self.definition.validators,'into'):
valeurspossibles = self.definition.validators.into
else:
@@ -359,20 +352,20 @@ class SIMPTreeItem(Objecttreeitem.AtomicObjectTreeItem):
else :
valeurspossibles=(valeurspossibles,)
for item in valeurspossibles:
- encorevalide=self.valide_item(item)
+ encorevalide=self.valideItem(item)
if encorevalide :
listevalideitem.append(item)
- #on ne garde que les choix possibles qui passent le test de valide_liste_partielle
+ #on ne garde que les choix possibles qui passent le test de valideListePartielle
listevalideliste=[]
for item in listevalideitem:
- encorevalide=self.valide_liste_partielle(item,listeActuelle)
+ encorevalide=self.valideListePartielle(item,listeActuelle)
if encorevalide :
listevalideliste.append(item)
#print listevalideliste
return listevalideliste
- def get_liste_possible_avecSug(self,listeActuelle=[]):
+ def getListePossibleAvecSug(self,listeActuelle=[]):
if hasattr(self.definition,'intoSug'):
valeurspossibles = self.definition.intoSug
else:
@@ -388,24 +381,24 @@ class SIMPTreeItem(Objecttreeitem.AtomicObjectTreeItem):
else :
valeurspossibles=(valeurspossibles,)
for item in valeurspossibles:
- encorevalide=self.valide_item(item)
+ encorevalide=self.valideItem(item)
if encorevalide :
listevalideitem.append(item)
- #on ne garde que les choix possibles qui passent le test de valide_liste_partielle
+ #on ne garde que les choix possibles qui passent le test de valideListePartielle
listevalideliste=[]
for item in listevalideitem:
- encorevalide=self.valide_liste_partielle(item,listeActuelle)
+ encorevalide=self.valideListePartielle(item,listeActuelle)
if encorevalide :
listevalideliste.append(item)
return listevalideliste
- def get_liste_param_possible(self):
+ def getListeParamPossible(self):
liste_param=[]
l1,l2=self.jdc.get_parametres_fonctions_avant_etape(self.get_etape())
for param in self.object.jdc.params:
if param.nom not in l1 : continue
- encorevalide=self.valide_item(param.valeur)
+ encorevalide=self.valideItem(param.valeur)
if encorevalide:
type_param=param.valeur.__class__.__name__
for typ in self.definition.type:
@@ -424,36 +417,33 @@ class SIMPTreeItem(Objecttreeitem.AtomicObjectTreeItem):
# Methodes liees a la validite des valeurs saisies
#
#---------------------------------------------------
- # valide_item
- # valide_liste_partielle
- # valide_liste_complete
- # info_erreur_item
- # info_erreur_liste
- # IsInIntervalle
- # isvalid
-
- def valide_item(self,item):
+ # valideItem
+ # valideListePartielle
+ # valideListeComplete
+ # infoErreurItem
+ # infoErreurListe
+ # isInIntervalle
+ # isValid
+
+ def valideItem(self,item):
"""
La validation est realisee directement par l'objet
"""
- return self.object.valide_item(item)
+ return self.object.valideItem(item)
- def valide_liste_partielle(self,item,listecourante):
+ def valideListePartielle(self,item,listecourante):
#On protege la liste en entree en la copiant
- valeur=listecourante[:]
- valeur.append(item)
+ valeur=list(listecourante)
+ if item : valeur.append(item)
return self.object.valid_valeur_partielle(valeur)
- def valide_liste_complete (self,valeur):
+ def valideListeComplete (self,valeur):
return self.object.valid_valeur(valeur)
- def valide_val (self,valeur):
- return self.object.valid_val(valeur)
-
- def info_erreur_item(self) :
+ def infoErreurItem(self) :
commentaire=""
if self.definition.validators :
- commentaire=self.definition.validators.info_erreur_item()
+ commentaire=self.definition.validators.infoErreurItem()
return commentaire
def aide(self) :
@@ -462,21 +452,21 @@ class SIMPTreeItem(Objecttreeitem.AtomicObjectTreeItem):
commentaire=self.definition.validators.aide()
return commentaire
- def info_erreur_liste(self) :
+ def infoErreurListe(self) :
commentaire=""
if self.definition.validators :
- commentaire=self.definition.validators.info_erreur_liste()
+ commentaire=self.definition.validators.infoErreurListe()
return commentaire
- def IsInIntervalle(self,valeur):
+ def isInIntervalle(self,valeur):
"""
Retourne 1 si la valeur est dans l'intervalle permis par
l'objet represente par l'item.
"""
- return self.valide_item(valeur)
+ return self.valideItem(valeur)
- def isvalid(self):
- valide=self.object.isvalid()
+ def isValid(self):
+ valide=self.object.isValid()
return valide
#--------------------------------------------------
@@ -484,56 +474,56 @@ class SIMPTreeItem(Objecttreeitem.AtomicObjectTreeItem):
# Autres ...
#
#---------------------------------------------------
- # GetIconName
- # GetText
- # set_valeur_co
- # get_sd_avant_du_bon_type
- # delete_valeur_co
+ # getIconName
+ # getText
+ # setValeurCo
+ # getSdAvantDuBonType
- def GetIconName(self):
+ def getIconName(self):
if self.isvalid():
+ if self.object.valeur == self.object.definition.defaut :
+ return "ast-green-dark-ball"
return "ast-green-ball"
- elif self.object.isoblig():
+ elif self.object.isOblig():
return "ast-red-ball"
else:
return "ast-yel-ball"
- def GetText(self):
+ def getText(self):
"""
Classe SIMPTreeItem
Retourne le texte a afficher dans l'arbre representant la valeur de l'objet
pointe par self
"""
- text= self.object.GetText()
+ text= self.object.getText()
if text == None : text=""
return text
- def set_valeur_co(self,nom_co):
+ def setValeurCo(self,nom_co):
"""
Affecte au MCS pointé par self l'objet de type CO et de nom nom_co
"""
- ret = self.object.set_valeur_co(nom_co)
- #print "set_valeur_co",ret
+ ret = self.object.setValeurCo(nom_co)
+ #print "setValeurCo",ret
return ret
- def get_sd_avant_du_bon_type(self):
+ def getSdAvantDuBonType(self):
"""
Retourne la liste des noms des SD présentes avant l'étape qui contient
le MCS pointé par self et du type requis par ce MCS
"""
- a=self.object.etape.parent.get_sd_avant_du_bon_type(self.object.etape,self.object.definition.type)
+ a=self.object.etape.parent.getSdAvantDuBonType(self.object.etape,self.object.definition.type)
return a
- def get_sd_avant_du_bon_type_pour_type_de_base(self):
- a=self.object.jdc.get_sd_avant_du_bon_type_pour_type_de_base(self.object.etape,"LASSD")
+ def getSdAvantDuBonTypePourTypeDeBase(self):
+ a=self.object.jdc.getSdAvantDuBonTypePourTypeDe_Base(self.object.etape,"LASSD")
return a
-
- def delete_valeur_co(self,valeur=None):
+ def deleteValeurCo(self,valeur=None):
"""
Supprime la valeur du mot cle (de type CO)
il faut propager la destruction aux autres etapes
@@ -541,29 +531,29 @@ class SIMPTreeItem(Objecttreeitem.AtomicObjectTreeItem):
if not valeur : valeur=self.object.valeur
# XXX faut il vraiment appeler del_sdprod ???
#self.object.etape.parent.del_sdprod(valeur)
- self.object.etape.parent.delete_concept(valeur)
+ self.object.etape.parent.deleteConcept(valeur)
#-----------------------------------------------
#
# Methodes liees au type de l objet attendu
#
#-----------------------------------------------
- # wait_co
- # wait_geom
- # wait_complex
- # wait_reel
- # wait_assd
- # GetType
-
- def wait_co(self):
+ # waitCo
+ # waitGeom
+ # waitComplex
+ # waitReel
+ # waitAssd
+ # getType
+
+ def waitCo(self):
"""
Méthode booléenne qui retourne 1 si l'objet pointé par self
attend un objet de type ASSD qui n'existe pas encore (type CO()),
0 sinon
"""
- return self.object.wait_co()
+ return self.object.waitCo()
- def wait_fichier(self):
+ def waitFichier(self):
maDefinition=self.object.definition
try :
if ('Repertoire' in maDefinition.type[0]) or ('Fichier' in maDefinition.type[0]) :
@@ -571,18 +561,18 @@ class SIMPTreeItem(Objecttreeitem.AtomicObjectTreeItem):
except :
return 0
- def wait_geom(self):
+ def waitGeom(self):
"""
Méthode booléenne qui retourne 1 si l'objet pointé par self
attend un objet GEOM, 0 sinon
"""
- return self.object.wait_geom()
+ return self.object.waitGeom()
- def wait_TXM(self):
- return self.object.wait_TXM()
+ def waitTxm(self):
+ return self.object.waitTxm()
- def wait_complex(self):
+ def waitComplex(self):
""" Méthode booléenne qui retourne 1 si l'objet pointé par self
attend un complexe, 0 sinon """
if 'C' in self.object.definition.type:
@@ -590,7 +580,7 @@ class SIMPTreeItem(Objecttreeitem.AtomicObjectTreeItem):
else:
return 0
- def wait_reel(self):
+ def waitReel(self):
""" Méthode booléenne qui retourne 1 si l'objet pointé par self
attend un réel, 0 sinon """
if 'R' in self.object.definition.type:
@@ -598,7 +588,7 @@ class SIMPTreeItem(Objecttreeitem.AtomicObjectTreeItem):
else:
return 0
- def wait_date(self):
+ def waitDate(self):
""" Méthode booléenne qui retourne 1 si l'objet pointé par self
attend un réel, 0 sinon """
if 'DateHHMMAAAA' in self.object.definition.type:
@@ -606,7 +596,7 @@ class SIMPTreeItem(Objecttreeitem.AtomicObjectTreeItem):
else:
return 0
- def wait_heure(self):
+ def waitHeure(self):
""" Méthode booléenne qui retourne 1 si l'objet pointé par self
attend un réel, 0 sinon """
if 'HeureHHMMSS' in self.object.definition.type:
@@ -616,7 +606,7 @@ class SIMPTreeItem(Objecttreeitem.AtomicObjectTreeItem):
- def wait_tuple(self):
+ def waitTuple(self):
""" Méthode booléenne qui retourne 1 si l'objet pointé par self
attend un Tuple, 0 sinon """
for ss_type in self.object.definition.type:
@@ -624,7 +614,7 @@ class SIMPTreeItem(Objecttreeitem.AtomicObjectTreeItem):
return 1
return 0
- def wait_matrice(self):
+ def waitMatrice(self):
""" Méthode booléenne qui retourne 1 si l'objet pointé par self
attend un Tuple, 0 sinon """
for ss_type in self.object.definition.type:
@@ -632,21 +622,21 @@ class SIMPTreeItem(Objecttreeitem.AtomicObjectTreeItem):
return 1
return 0
- def wait_assd(self):
+ def waitAssd(self):
"""Méthode booléenne qui retourne 1 si l'objet pointé par self
attend un objet de type ASSD ou dérivé, 0 sinon """
- return self.object.wait_assd()
+ return self.object.waitAssd()
- def wait_assd_or_type_base(self) :
+ def waitAssdOrTypeBase(self) :
boo=0
if len(self.object.definition.type) > 1 :
- if self.wait_reel() :
+ if self.waitReel() :
boo = 1
if 'I' in self.object.definition.type :
boo = 1
return boo
- def wait_Salome(self):
+ def waitSalome(self):
monType = self.object.definition.type[0]
if 'grma' in repr(monType) : return True
if 'grno' in repr(monType) : return True
@@ -656,23 +646,23 @@ class SIMPTreeItem(Objecttreeitem.AtomicObjectTreeItem):
pass
return False
- def GetType(self):
+ def getType(self):
"""
Retourne le type de valeur attendu par l'objet représenté par l'item.
"""
- return self.object.get_type()
+ return self.object.getType()
#-----------------------------------------------------
#
# Methodes liees a l evaluation de la valeur saisie
#
#-----------------------------------------------------
- # eval_valeur
- # eval_valeur_item
- # is_CO
- # traite_reel
+ # evalValeur
+ # evalValeurItem
+ # isCO
+ # traiteReel
- def eval_valeur(self,valeur):
+ def evalValeur(self,valeur):
""" Lance l'interpretation de 'valeur' (chaine de caracteres) comme valeur de self :
- retourne l'objet associe si on a pu interpreter (entier, reel, ASSD,...)
- retourne 'valeur' (chaine de caracteres) sinon
@@ -680,76 +670,55 @@ class SIMPTreeItem(Objecttreeitem.AtomicObjectTreeItem):
newvaleur=self.eval_val(valeur)
return newvaleur,1
- def eval_valeur_BAK(self,valeur):
- """ Lance l'interpretation de 'valeur' (chaine de caractéres) comme valeur
- de l'objet pointé par self :
- - retourne l'objet associé si on a pu interpréter (entier, réel, ASSD,...)
- - retourne 'valeur' (chaine de caractéres) sinon
- - retourne None en cas d invalidite
- - retourne invalide si 1 des objets du tuple l est
- """
- validite=1
- if type(valeur) in (list,tuple) :
- valeurretour=[]
- for item in valeur :
- newvaleur,validiteitem=self.eval_valeur_item(item)
- valeurretour.append(newvaleur)
- if validiteitem == 0:
- validite=0
- else :
- valeurretour,validite= self.eval_valeur_item(valeur)
- if validite == 0 :
- valeurretour = None
- return valeurretour,validite
- def eval_valeur_item(self,valeur):
+ def evalValeurItem(self,valeur):
""" Lance l'interprétation de 'valeur' qui doit ne pas etre un tuple
- va retourner la valeur de retour et la validite
selon le type de l objet attendu
- traite les reels et les parametres
"""
- #print "eval_valeur_item",valeur
+ #print "evalValeurItem",valeur
if valeur==None or valeur == "" :
return None,0
validite=1
- if self.wait_reel():
- valeurinter = self.traite_reel(valeur)
+ if self.waitReel():
+ valeurinter = self.traiteReel(valeur)
if valeurinter != None :
- valeurretour,validite= self.object.eval_valeur(valeurinter)
+ valeurretour,validite= self.object.evalValeur(valeurinter)
else:
- valeurretour,validite= self.object.eval_valeur(valeur)
- elif self.wait_geom():
+ valeurretour,validite= self.object.evalValeur(valeur)
+ elif self.waitGeom():
valeurretour,validite = valeur,1
else :
- valeurretour,validite= self.object.eval_valeur(valeur)
- #print "eval_valeur_item",valeurretour,validite
+ valeurretour,validite= self.object.evalValeur(valeur)
+ #print "evalValeurItem",valeurretour,validite
if validite == 0:
- if type(valeur) == bytes and self.object.wait_TXM():
+ if type(valeur) == bytes and self.object.waitTxm():
essai_valeur="'" + valeur + "'"
- valeurretour,validite= self.object.eval_valeur(essai_valeur)
+ valeurretour,validite= self.object.evalValeur(essai_valeur)
if hasattr(valeurretour,'__class__'):
#if valeurretour.__class__.__name__ in ('PARAMETRE','PARAMETRE_EVAL'):
if valeurretour.__class__.__name__ in ('PARAMETRE',):
validite=1
- #if self.wait_co():
+ #if self.waitCo():
# CCAR : il ne faut pas essayer de creer un concept
- # il faut simplement en chercher un existant ce qui a du etre fait par self.object.eval_valeur(valeur)
+ # il faut simplement en chercher un existant ce qui a du etre fait par self.object.evalValeur(valeur)
#try:
#valeurretour=Accas.CO(valeur)
#except:
#valeurretour=None
#validite=0
# on est dans le cas ou on a évalué et ou on n'aurait pas du
- if self.object.wait_TXM() :
+ if self.object.waitTxm() :
if type(valeurretour) != bytes:
valeurretour=str(valeur)
validite=1
return valeurretour,validite
- def is_CO(self,valeur=None):
+ def isCO(self,valeur=None):
"""
Indique si valeur est un concept produit de la macro
Cette méthode n'a de sens que pour un MCSIMP d'une MACRO
@@ -767,20 +736,20 @@ class SIMPTreeItem(Objecttreeitem.AtomicObjectTreeItem):
if valeur.__class__.__name__ == 'CO':return 1
return 0
- def is_param(self,valeur) :
+ def isParam(self,valeur) :
for param in self.jdc.params:
if (repr(param) == valeur):
return 1
return 0
- def traite_reel(self,valeur):
+ def traiteReel(self,valeur):
"""
Cette fonction a pour but de rajouter le '.' en fin de chaine pour un réel
ou de détecter si on fait référence a un concept produit par DEFI_VALEUR
ou un EVAL ...
"""
valeur = valeur.strip()
- liste_reels = self.get_sd_avant_du_bon_type()
+ liste_reels = self.getSdAvantDuBonType()
if valeur in liste_reels:
return valeur
if len(valeur) >= 3 :
@@ -789,7 +758,7 @@ class SIMPTreeItem(Objecttreeitem.AtomicObjectTreeItem):
return valeur
if valeur.find('.') == -1 :
# aucun '.' n'a été trouvé dans valeur --> on en rajoute un a la fin
- if (self.is_param(valeur)):
+ if (self.isParam(valeur)):
return valeur
else:
if valeur.find('e') != -1:
diff --git a/InterfaceQT4/configuration.py b/InterfaceQT4/configuration.py
index 3c64fc4e..29c799e7 100644
--- a/InterfaceQT4/configuration.py
+++ b/InterfaceQT4/configuration.py
@@ -52,6 +52,7 @@ class CONFIG_BASE(object):
# par celui de l utilisateur
# le fichier de catalogue va etre lu dans la directory de l utilisateur s il exite
# dans le fichier general sinon
+
self.appli = appli
self.code = appli.code
self.salome = appli.salome
@@ -64,7 +65,6 @@ class CONFIG_BASE(object):
else :
self.rep_user = os.path.join('C:/','.config/Eficas',appli.code)
-
self.setValeursParDefaut()
@@ -72,6 +72,10 @@ class CONFIG_BASE(object):
self.lecture_fichier_ini_integrateur()
self.lecture_fichier_ini_utilisateur()
+ if self.boutonDsMenuBar:
+ self.closeAutreCommande = True
+ self.closeFrameRechercheCommande = True
+
#Particularite des schemas MAP
if hasattr(self,'make_ssCode'): self.make_ssCode(self.ssCode)
@@ -98,7 +102,7 @@ class CONFIG_BASE(object):
self.savedir = os.path.abspath(os.path.join(os.environ['HOME'],nomDir))
else:
self.savedir = os.path.abspath('C:/')
- self.mode_nouv_commande='initial'
+ self.modeNouvCommande='initial'
self.affiche="alpha"
self.closeAutreCommande = False
self.closeFrameRechercheCommande = False
@@ -112,6 +116,11 @@ class CONFIG_BASE(object):
self.simpleClic= False
self.afficheOptionnelVide=False
self.afficheListesPliees=True
+ self.boutonDsMenuBar=False
+ self.ficIcones=None
+ self.repIcones=None
+ self.differencieSiDefaut=True
+
#--------------------------------------
diff --git a/InterfaceQT4/editor.py b/InterfaceQT4/editor.py
index aeed8938..8b63940f 100755
--- a/InterfaceQT4/editor.py
+++ b/InterfaceQT4/editor.py
@@ -30,7 +30,7 @@ import traceback
import six
from six.moves import range
-from PyQt5.QtWidgets import QWidget, QMessageBox, QFileDialog, QApplication, QSplitter
+from PyQt5.QtWidgets import QWidget, QMessageBox, QFileDialog, QApplication, QSplitter, QLabel
from PyQt5.QtGui import QPalette
from PyQt5.QtCore import QProcess, QFileInfo, QTimer, Qt, QDir, QSize
import time
@@ -93,7 +93,7 @@ class JDCEditor(Ui_baseWidget,QWidget):
print ("dans JDC pas d appli ????????")
# ces attributs sont mis a jour par definitCode appelee par newEditor
- self.code = self.appliEficas.CONFIGURATION.code
+ self.code = self.appliEficas.maConfiguration.code
self.initSplitterSizes()
#self.afficheListesPliees=False
@@ -101,16 +101,16 @@ class JDCEditor(Ui_baseWidget,QWidget):
if self.code == "ASTER" or self.code == "monCode" : self.afficheListesPliees =True
if self.code == 'PSEN_N1' : self.afficheListesPliees = False
- self.mode_nouv_commande=self.appliEficas.CONFIGURATION.mode_nouv_commande
- self.closeAutreCommande=self.appliEficas.CONFIGURATION.closeAutreCommande
- self.closeFrameRechercheCommande=self.appliEficas.CONFIGURATION.closeFrameRechercheCommande
- self.closeArbre=self.appliEficas.CONFIGURATION.closeArbre
- self.affiche=self.appliEficas.CONFIGURATION.affiche
- self.afficheOptionnelVide=self.appliEficas.CONFIGURATION.afficheOptionnelVide
- self.nombreDeBoutonParLigne = self.appliEficas.CONFIGURATION.nombreDeBoutonParLigne
- self.dicoImages = self.appliEficas.CONFIGURATION.dicoImages
- self.simpleClic = self.appliEficas.CONFIGURATION.simpleClic
- #self.taille = self.appliEficas.taille
+ self.maConfiguration=self.appliEficas.maConfiguration
+ self.closeAutreCommande=self.appliEficas.maConfiguration.closeAutreCommande
+ self.closeFrameRechercheCommande = self.appliEficas.maConfiguration.closeFrameRechercheCommande
+ self.closeArbre=self.appliEficas.maConfiguration.closeArbre
+ self.affiche=self.appliEficas.maConfiguration.affiche
+ self.afficheOptionnelVide=self.appliEficas.maConfiguration.afficheOptionnelVide
+ self.nombreDeBoutonParLigne = self.appliEficas.maConfiguration.nombreDeBoutonParLigne
+ self.dicoImages = self.appliEficas.maConfiguration.dicoImages
+ self.simpleClic = self.appliEficas.maConfiguration.simpleClic
+ self.boutonDsMenuBar = self.appliEficas.maConfiguration.boutonDsMenuBar
#if self.code in ['MAP','CARMELCND','PSEN'] : self.afficheCommandesPliees=False
if self.code in ['MAP','CARMELCND'] : self.afficheCommandesPliees=False
@@ -126,8 +126,10 @@ class JDCEditor(Ui_baseWidget,QWidget):
self.readercata = readercata.READERCATA( self, self.appliEficas )
self.appliEficas.readercata=self.readercata
self.appliEficas.code=self.code
+ if self.boutonDsMenuBar : self.appliEficas.remplitIconesCommandes()
else :
self.readercata=self.appliEficas.readercata
+
if self.readercata.fic_cata == None : return #Sortie Salome
self.titre=self.readercata.titre
self.Ordre_Des_Commandes=self.readercata.Ordre_Des_Commandes
@@ -143,21 +145,21 @@ class JDCEditor(Ui_baseWidget,QWidget):
nameConf='configuration_'+self.code
configuration=__import__(nameConf)
- self.CONFIGURATION = self.appliEficas.CONFIGURATION
+ self.maConfiguration = self.appliEficas.maConfiguration
self.CONFIGStyle = self.appliEficas.CONFIGStyle
try:
- self.CONFIGURATION.generator_module
- _module = __import__(self.CONFIGURATION.generator_module)
+ self.maConfiguration.generator_module
+ _module = __import__(self.maConfiguration.generator_module)
info = _module.entryPoint()
generator.plugins.addEntryPoint(info)
except:
pass
try:
- self.CONFIGURATION.convert_module
- #print self.CONFIGURATION.convert_module
- _module = __import__(self.CONFIGURATION.convert_module)
+ self.maConfiguration.convert_module
+ #print self.maConfiguration.convert_module
+ _module = __import__(self.maConfiguration.convert_module)
info = _module.entryPoint()
convert.plugins.addEntryPoint(info)
except :
@@ -193,7 +195,9 @@ class JDCEditor(Ui_baseWidget,QWidget):
self.fileInfo = QFileInfo(self.fichier)
self.fileInfo.setCaching(0)
if jdc==None :
+ print ('attention chgt try en if')
try :
+ #if 1 :
self.jdc = self.readFile(self.fichier)
if self.salome : self.appliEficas.addJdcInSalome( self.fichier)
except :
@@ -210,6 +214,9 @@ class JDCEditor(Ui_baseWidget,QWidget):
else :
self.jdc = self._newJDCInclude(units=units)
self.nouveau=1
+ #import cProfile, pstats, StringIO
+ #pr = cProfile.Profile()
+ #pr.enable()
if self.jdc:
self.jdc.appli = self # a resorber
@@ -223,17 +230,22 @@ class JDCEditor(Ui_baseWidget,QWidget):
if txt_exception:
self.jdc = None
QApplication.restoreOverrideCursor()
- self.affiche_infos(tr("Erreur fatale au chargement de %s",str(fichier)),Qt.red)
+ self.afficheInfos(tr("Erreur fatale au chargement de %s",str(fichier)),Qt.red)
if (self.appliEficas.ssIhm == False) : QMessageBox.critical( self, tr("Erreur fatale au chargement d'un fichier"), txt_exception)
else:
- comploader.charger_composants("QT")
- jdc_item=Objecttreeitem.make_objecttreeitem( self, "nom", self.jdc )
- if (not self.jdc.isvalid()) and (not self.nouveau) and (self.appliEficas.ssIhm == False):
+ comploader.chargerComposants("QT")
+ jdc_item=Objecttreeitem.makeObjecttreeitem( self, "nom", self.jdc )
+ if (not self.jdc.isValid()) and (not self.nouveau) and (self.appliEficas.ssIhm == False):
self.viewJdcRapport()
-
-
- if jdc_item and self.appliEficas.ssIhm==False:
+ #pr.disable()
+ #s = StringIO.StringIO()
+ #sortby = 'cumulative'
+ #ps = pstats.Stats(pr, stream=s).sort_stats(sortby)
+ #ps.print_stats()
+ #print (s.getvalue())
+
+ if jdc_item and self.appliEficas.ssIhm==False :
self.tree = browser.JDCTree( jdc_item, self )
self.appliEficas.construitMenu()
@@ -267,7 +279,7 @@ class JDCEditor(Ui_baseWidget,QWidget):
path1 = os.path.abspath(os.path.join(os.path.abspath(__file__), '../','../','ProcessOutputs_Eficas','TreatOutputs'))
sys.path.append(path1)
- if not(self.jdc.isvalid()):
+ if not(self.jdc.isValid()):
QMessageBox.information( self, tr( "Unvalid JDC"),tr("incorrect keywords will be ignored"))
if 'dicoImbrique' in generator.plugins:
self.generator=generator.plugins['dicoImbrique']()
@@ -302,7 +314,7 @@ class JDCEditor(Ui_baseWidget,QWidget):
if 'dicoImbrique' in generator.plugins:
self.generator=generator.plugins['dicoImbrique']()
jdc_formate=self.generator.gener(self.jdc)
- dico=self.get_Dico() #generator.Dico
+ dico=self.getDico() #generator.Dico
for k in dico['CONTINGENCY_PROCESSING']:
@@ -321,7 +333,7 @@ class JDCEditor(Ui_baseWidget,QWidget):
###
return dico
- #return self.get_Dico()
+ #return self.getDico()
#-------------------# Pour execution avec output et error dans le bash
def process_VP(self):
@@ -329,7 +341,7 @@ class JDCEditor(Ui_baseWidget,QWidget):
if 'dicoImbrique' in generator.plugins:
self.generator=generator.plugins['dicoImbrique']()
jdc_formate=self.generator.gener(self.jdc)
- dico=self.get_Dico() #generator.Dico
+ dico=self.getDico() #generator.Dico
return dico
@@ -341,7 +353,7 @@ class JDCEditor(Ui_baseWidget,QWidget):
return
noeudAvantCommentaire=self.tree.selectedItems()[0]
if noeudAvantCommentaire ==self.tree.racine :
- self.tree.racine.append_child("COMMENTAIRE",pos=0)
+ self.tree.racine.appendChild("COMMENTAIRE",pos=0)
return
noeudAvantCommentaire.addComment(True)
@@ -372,7 +384,7 @@ class JDCEditor(Ui_baseWidget,QWidget):
appli=self,
cata=self.readercata.cata,
cata_ord_dico=self.readercata.cata_ordonne_dico,
- rep_mat=self.CONFIGURATION.rep_mat
+ rep_mat=self.maConfiguration.rep_mat
)
jdc.lang = self.appli.langue
if units is not None:
@@ -396,7 +408,7 @@ class JDCEditor(Ui_baseWidget,QWidget):
appli=self,
cata=self.readercata.cata,
cata_ord_dico=self.readercata.cata_ordonne_dico,
- rep_mat=self.CONFIGURATION.rep_mat,
+ rep_mat=self.maConfiguration.rep_mat,
)
jaux.analyse()
@@ -405,7 +417,7 @@ class JDCEditor(Ui_baseWidget,QWidget):
cata=self.readercata.cata,
cata_ord_dico=self.readercata.cata_ordonne_dico,
jdc_pere=jaux,
- rep_mat=self.CONFIGURATION.rep_mat,
+ rep_mat=self.maConfiguration.rep_mat,
)
J.analyse()
if units is not None:
@@ -433,11 +445,12 @@ class JDCEditor(Ui_baseWidget,QWidget):
# Le convertisseur existe on l'utilise
#appli = self
p=convert.plugins[self.appliEficas.format_fichier_in]()
-
+
+
p.readfile(fn)
if p.text=="" : self.nouveau=1
- pareil,texteNew=self.verifieCHECKSUM(p.text)
+ pareil,texteNew=self.verifieChecksum(p.text)
#if texteNew == ""
if pareil == False and (self.appliEficas.ssIhm == False) :
QMessageBox.warning( self, tr("fichier modifie"),tr("Attention! fichier change hors EFICAS"))
@@ -451,17 +464,11 @@ class JDCEditor(Ui_baseWidget,QWidget):
#pr.enable()
text=p.convert('exec',self.appliEficas)
- #pr.disable()
- #s = StringIO.StringIO()
- #sortby = 'cumulative'
- #ps = pstats.Stats(pr, stream=s).sort_stats(sortby)
- #ps.print_stats()
- #print (s.getvalue())
if not p.cr.estvide():
- self.affiche_infos("Erreur a la conversion",Qt.red)
+ self.afficheInfos("Erreur a la conversion",Qt.red)
else :
- self.affiche_infos("Type de fichier non reconnu",Qt.red)
+ self.afficheInfos("Type de fichier non reconnu",Qt.red)
if self.appliEficas.ssIhm == False:
QMessageBox.critical( self, tr("Type de fichier non reconnu"),
tr("EFICAS ne sait pas ouvrir le type de fichier %s" ,self.appliEficas.format_fichier_in))
@@ -473,7 +480,7 @@ class JDCEditor(Ui_baseWidget,QWidget):
cata=self.readercata.cata,
cata_ord_dico=self.readercata.cata_ordonne_dico,
nom=jdcName,
- rep_mat=self.CONFIGURATION.rep_mat
+ rep_mat=self.maConfiguration.rep_mat
)
# ----------------------------------------------------
# charge le JDC fin
@@ -487,11 +494,12 @@ class JDCEditor(Ui_baseWidget,QWidget):
self.lastModified = 1
nouveauTitre=self.titre+" "+os.path.basename(self.fichier)
self.appliEficas.setWindowTitle(nouveauTitre)
+
return jdc
#-----------------------#
- def get_source(self,file):
+ def getSource(self,file):
#-----------------------#
# Il faut convertir le contenu du fichier en fonction du format
@@ -501,11 +509,11 @@ class JDCEditor(Ui_baseWidget,QWidget):
p.readfile(file)
text=p.convert('execnoparseur')
if not p.cr.estvide():
- self.affiche_infos("Erreur a la conversion",Qt.red)
+ self.afficheInfos("Erreur a la conversion",Qt.red)
return text
else:
# Il n'existe pas c'est une erreur
- self.affiche_infos("Type de fichier non reconnu",Qt.red)
+ self.afficheInfos("Type de fichier non reconnu",Qt.red)
QMessageBox.critical( self, tr("Type de fichier non reconnu"),tr("EFICAS ne sait pas ouvrir ce type de fichier"))
return None
@@ -592,7 +600,7 @@ class JDCEditor(Ui_baseWidget,QWidget):
#-----------------------#
def viewJdcPy(self):
#-----------------------#
- strSource = str( self.get_text_JDC(self.format) )
+ strSource = str( self.getTextJDC(self.format) )
self._viewText(strSource, "JDC_RESULTAT")
#-----------------------#
@@ -606,7 +614,7 @@ class JDCEditor(Ui_baseWidget,QWidget):
#-----------------------#
def viewJdcRegles(self):
#-----------------------#
- if self.tree :self.tree.AppelleBuildLBRegles()
+ if self.tree :self.tree.appellebuildLBRegles()
#----------------#
@@ -620,7 +628,7 @@ class JDCEditor(Ui_baseWidget,QWidget):
self.close()
#----------------------------------------------#
- def affiche_infos(self,message,couleur=Qt.black):
+ def afficheInfos(self,message,couleur=Qt.black):
#----------------------------------------------#
if self.sb:
mapalette=self.sb.palette()
@@ -630,13 +638,13 @@ class JDCEditor(Ui_baseWidget,QWidget):
self.couleur=couleur
#------------------------------#
- def affiche_alerte(self,titre,message):
+ def afficheAlerte(self,titre,message):
#------------------------------#
# appele par I_MACRO_ETAPE
QMessageBox.information( self, titre, message)
#-----------------------------------#
- def affiche_commentaire(self,message):
+ def afficheCommentaire(self,message):
#-----------------------------------#
self.labelCommentaire.setText(message)
QTimer.singleShot(6000, self.rendInvisible)
@@ -647,7 +655,7 @@ class JDCEditor(Ui_baseWidget,QWidget):
self.labelCommentaire.setText("")
#-------------------#
- def init_modif(self):
+ def initModif(self):
#-------------------#
"""
Met l'attribut modified a 'o' : utilise par Eficas pour savoir
@@ -730,8 +738,8 @@ class JDCEditor(Ui_baseWidget,QWidget):
"""
self.chercheNoeudSelectionne()
if len(self.node_selected) == 0 : return
- if len(self.node_selected) == 1 : self.node_selected[0].update_node_label_in_blue()
- else : self.node_selected[0].update_plusieurs_node_label_in_blue(self.node_selected)
+ if len(self.node_selected) == 1 : self.node_selected[0].updateNodeLabelInBlue()
+ else : self.node_selected[0].updatePlusieursNodeLabelInBlue(self.node_selected)
self.QWParent.edit="copier"
self.QWParent.noeud_a_editer = self.node_selected
@@ -773,21 +781,21 @@ class JDCEditor(Ui_baseWidget,QWidget):
if child==None or child==0:
QMessageBox.critical( self,tr( "Copie refusee"),tr('Eficas n a pas reussi a copier l objet'))
self.message = ''
- self.affiche_infos("Copie refusee",Qt.red)
+ self.afficheInfos("Copie refusee",Qt.red)
if noeudACopier.treeParent.editor != noeudOuColler.treeParent.editor:
try :
nom=noeudACopier.item.sd.nom
- child.item.nomme_sd(nom)
+ child.item.nommeSd(nom)
except :
pass
return
- self.init_modif()
+ self.initModif()
child.select()
except :
traceback.print_exc()
QMessageBox.critical( self,tr( "Copie refusee"),tr('Copie refusee pour ce type d objet'))
self.message = ''
- self.affiche_infos("Copie refusee",Qt.red)
+ self.afficheInfos("Copie refusee",Qt.red)
return
# il faut declarer le JDCDisplay_courant modifie
@@ -804,7 +812,7 @@ class JDCEditor(Ui_baseWidget,QWidget):
# indexNoeudACopier=noeudACopier.treeParent.children.index(noeudACopier)
indexNoeudACopier=self.getTreeIndex(noeudACopier)
noeudACopier.treeParent.item.deplaceEntite(indexNoeudACopier,indexNoeudOuColler,pos)
- noeudACopier.treeParent.build_children()
+ noeudACopier.treeParent.buildChildren()
#else:
except:
@@ -880,11 +888,32 @@ class JDCEditor(Ui_baseWidget,QWidget):
listeASupprimer.append(noeud)
for i in range(len(listeChild)):
- self.tree.item.suppitem(listeItem[i])
+ self.tree.item.suppItem(listeItem[i])
listeChild[i].item.update(listeItem[i])
self.QWParent.noeud_a_editer = []
+ #----------------------------------#
+ def handleAjoutEtape(self,nomEtape):
+ #----------------------------------#
+ self.chercheNoeudSelectionne()
+ if len(self.node_selected) == 0 or self.node_selected[0] == self.tree.racine :
+ nodeOuAjouter=self.tree.racine
+ nouveau=nodeOuAjouter.appendChild(nomEtape,pos='first')
+ else :
+ nodeOuAjouter=self.node_selected[0]
+ if nodeOuAjouter != self.tree.racine :
+ while nodeOuAjouter.treeParent != self.tree.racine:
+ print (nodeOuAjouter)
+ nodeOuAjouter=nodeOuAjouter.treeParent
+ print (nodeOuAjouter.parent == self.tree.racine)
+ nouveau=nodeOuAjouter.appendBrother(nomEtape)
+ try :
+ self.node_selected[0].setSelected(False)
+ except : pass
+ nouveau.setSelected(True)
+ nouveau.affichePanneau()
+
#---------------------#
def getFileName(self):
@@ -892,7 +921,7 @@ class JDCEditor(Ui_baseWidget,QWidget):
return self.fichier
#---------------------------#
- def get_file_variable(self) :
+ def getFileVariable(self) :
#---------------------------#
titre = tr("Choix d'un fichier XML")
texte = tr("Le fichier contient une commande MODEL\n")
@@ -901,7 +930,7 @@ class JDCEditor(Ui_baseWidget,QWidget):
fichier = QFileDialog.getOpenFileName(self.appliEficas,
tr('Ouvrir Fichier'),
- self.appliEficas.CONFIGURATION.savedir,
+ self.appliEficas.maConfiguration.savedir,
tr('Wrapper Files (*.xml);;''All Files (*)'))
return fichier
@@ -918,7 +947,7 @@ class JDCEditor(Ui_baseWidget,QWidget):
fn = six.text_type(fn)
if txt == None :
- txt = self.get_text_JDC(self.format,formatLigne=formatLigne)
+ txt = self.getTextJDC(self.format,formatLigne=formatLigne)
eol = '\n'
if len(txt) >= len(eol):
if txt[-len(eol):] != eol:
@@ -926,7 +955,7 @@ class JDCEditor(Ui_baseWidget,QWidget):
else:
txt += eol
txt=self.ajoutVersionCataDsJDC(txt)
- if self.code != 'PSEN' and self.code != 'PSEN_N1' : checksum=self.get_checksum(txt)
+ if self.code != 'PSEN' and self.code != 'PSEN_N1' : checksum=self.getChecksum(txt)
else : checksum=''
txt=txt+checksum
if self.code=="TELEMAC" : return 1
@@ -944,7 +973,7 @@ class JDCEditor(Ui_baseWidget,QWidget):
return 0
#-----------------------------------------------------------#
- def get_text_JDC(self,format,pourRun=0,formatLigne="beautifie"):
+ def getTextJDC(self,format,pourRun=0,formatLigne="beautifie"):
#-----------------------------------------------------------#
if self.code == "MAP" and not(format in generator.plugins): format = "MAP"
if format in generator.plugins:
@@ -952,7 +981,7 @@ class JDCEditor(Ui_baseWidget,QWidget):
# Le generateur existe on l'utilise
self.generator=generator.plugins[format]()
try :
- jdc_formate=self.generator.gener(self.jdc,format=formatLigne,config=self.appliEficas.CONFIGURATION,appli=self.appliEficas)
+ jdc_formate=self.generator.gener(self.jdc,format=formatLigne,config=self.appliEficas.maConfiguration,appli=self.appliEficas)
if pourRun : jdc_formate=self.generator.textePourRun
if self.code == 'TELEMAC' : jdc_formate=self.generator.texteDico
except ValueError as e:
@@ -960,19 +989,19 @@ class JDCEditor(Ui_baseWidget,QWidget):
return
if not self.generator.cr.estvide():
- self.affiche_infos(tr("Erreur a la generation"),Qt.red)
+ self.afficheInfos(tr("Erreur a la generation"),Qt.red)
QMessageBox.critical( self, tr("Erreur a la generation"),tr("EFICAS ne sait pas convertir ce JDC"))
return ""
else:
return jdc_formate
else:
# Il n'existe pas c'est une erreur
- self.affiche_infos(tr("Format %s non reconnu" , self.format),Qt.red)
+ self.afficheInfos(tr("Format %s non reconnu" , self.format),Qt.red)
QMessageBox.critical( self, "Format non reconnu" ,tr("EFICAS ne sait pas convertir le JDC selon le format "+ self.format))
return ""
#----------------------#
- def get_Dico(self):
+ def getDico(self):
#---------------------#
if 'dicoImbrique' in generator.plugins:
self.generator=generator.plugins['dicoImbrique']()
@@ -980,7 +1009,7 @@ class JDCEditor(Ui_baseWidget,QWidget):
dico=self.generator.Dico
return dico
else :
- self.affiche_infos(tr("Format %s non reconnu" , self.format),Qt.red)
+ self.afficheInfos(tr("Format %s non reconnu" , self.format),Qt.red)
QMessageBox.critical( self, "Format non reconnu" ,tr("EFICAS ne sait pas convertir le JDC selon le format "+ self.format))
return ""
@@ -1002,7 +1031,7 @@ class JDCEditor(Ui_baseWidget,QWidget):
def runMAP(self):
#---------------#
- if not(self.jdc.isvalid()):
+ if not(self.jdc.isValid()):
QMessageBox.critical( self, tr( "Execution impossible "),tr("le JDC doit etre valide pour une execution MAP"))
return
if len(self.jdc.etapes) != 1 :
@@ -1010,7 +1039,7 @@ class JDCEditor(Ui_baseWidget,QWidget):
return
if self.modified or self.fichier==None :
self.fichierMapInput = self.__generateTempFilename(prefix = "map_run", suffix = ".map")
- texte=self.get_text_JDC("MAP")
+ texte=self.getTextJDC("MAP")
self.writeFile( self.fichierMapInput, txt = texte)
else :
self.fichierMapInput=self.fichier
@@ -1041,13 +1070,13 @@ class JDCEditor(Ui_baseWidget,QWidget):
#-------------------#
def runZCRACKS(self):
#-------------------#
- if not(self.jdc.isvalid()):
+ if not(self.jdc.isValid()):
QMessageBox.critical( self, tr( "Execution impossible "),tr("le JDC doit etre valide pour une execution "))
return
if self.modified or self.fichier==None :
#if 1:
self.fichierZcracksInput = self.__generateTempFilename(prefix = "zcracks_run", suffix = ".z7p")
- texte=self.get_text_JDC("ZCRACKS",pourRun=1)
+ texte=self.getTextJDC("ZCRACKS",pourRun=1)
self.writeFile( self.fichierZcracksInput, txt = texte)
else :
self.fichierZcracksInput=self.fichier
@@ -1062,13 +1091,13 @@ class JDCEditor(Ui_baseWidget,QWidget):
#-------------------#
def runCARMELCND(self):
#-------------------#
- #if not(self.jdc.isvalid()):
+ #if not(self.jdc.isValid()):
# QMessageBox.critical( self, tr( "Execution impossible "),tr("le JDC doit etre valide pour une execution "))
# return
if self.modified or self.fichier==None :
QMessageBox.critical( self, tr( "Execution impossible "),tr("Sauvegarder SVP avant l'execution "))
return
- if not hasattr(self,'generator'): texte=self.get_text_JDC(self.format)
+ if not hasattr(self,'generator'): texte=self.getTextJDC(self.format)
from PrepareRunCarmel import prepareRunCarmel
fichierGenerique=os.path.basename(self.fichier).split(".")[0]
repMed=os.path.dirname(self.fichier)
@@ -1127,7 +1156,7 @@ class JDCEditor(Ui_baseWidget,QWidget):
def saveRunMAP(self):
#-----------------#
extension=".input"
- if not(self.jdc.isvalid()):
+ if not(self.jdc.isValid()):
QMessageBox.critical( self, tr( "Sauvegarde de l'input impossible "),
tr("Un JdC valide est necessaire pour creer un .input")
)
@@ -1139,7 +1168,7 @@ class JDCEditor(Ui_baseWidget,QWidget):
tr("Choix du composant obligatoire")
)
return
- if hasattr(self.CONFIGURATION, "savedir"): path=self.CONFIGURATION.savedir
+ if hasattr(self.maConfiguration, "savedir"): path=self.maConfiguration.savedir
else : path='C:/'
monNomFichier=""
@@ -1174,7 +1203,7 @@ class JDCEditor(Ui_baseWidget,QWidget):
if not hasattr(self, 'fichierMapInput') or not self.fichierMapInput or not os.path.exists(self.fichierMapInput):
self.fichierMapInput = self.__generateTempFilename(prefix = "map_run", suffix = ".map")
- texte=self.get_text_JDC("MAP")
+ texte=self.getTextJDC("MAP")
self.writeFile( self.fichierMapInput, txt = texte)
cmd = ("map gen -t dat -n " + composant + " -i " + self.fichierMapInput + " -o " + fn)
@@ -1190,20 +1219,20 @@ class JDCEditor(Ui_baseWidget,QWidget):
#-----------------------------------------#
- def cherche_Groupes(self):
+ def chercheGroupes(self):
#-----------------------------------------#
- listeMA,listeNO=self.get_text_JDC("GroupMA")
+ listeMA,listeNO=self.getTextJDC("GroupMA")
return listeMA,listeNO
#-----------------------------------------#
- def cherche_Dico(self):
+ def chercheDico(self):
#-----------------------------------------#
dicoCourant={}
format = self.appliEficas.format_fichier
if format in generator.plugins:
# Le generateur existe on l'utilise
self.generator=generator.plugins[format]()
- jdc_formate=self.generator.gener(self.jdc,format='beautifie',config=self.appliEficas.CONFIGURATION)
+ jdc_formate=self.generator.gener(self.jdc,format='beautifie',config=self.appliEficas.maConfiguration)
dicoCourant=self.generator.dico
return dicoCourant
@@ -1238,20 +1267,20 @@ class JDCEditor(Ui_baseWidget,QWidget):
#saveas=True # Pour forcer le nom
self.generator=generator.plugins[self.format]()
if self.fichier is None or saveas:
- if path is None: path=self.CONFIGURATION.savedir
+ if path is None: path=self.maConfiguration.savedir
bOK, fn=self.determineNomFichier(path,extension)
if bOK == 0 : return (0, None)
if fn == None : return (0, None)
if fn== '' : return (0, None)
ulfile = os.path.abspath(six.text_type(fn))
- self.appliEficas.CONFIGURATION.savedir=os.path.split(ulfile)[0]
+ self.appliEficas.maConfiguration.savedir=os.path.split(ulfile)[0]
fn = six.text_type(QDir.toNativeSeparators(fn))
self.fichier = os.path.splitext(fn)[0]+extension
if hasattr(self.generator, "writeLeger"):
- self.generator.writeLeger(self.fichier,self.jdc,config=self.appliEficas.CONFIGURATION,appli=self.appliEficas)
+ self.generator.writeLeger(self.fichier,self.jdc,config=self.appliEficas.maConfiguration,appli=self.appliEficas)
if self.salome : self.appliEficas.addJdcInSalome( self.fichier)
@@ -1283,14 +1312,14 @@ class JDCEditor(Ui_baseWidget,QWidget):
newName = None
fn = self.fichier
if self.fichier is None or saveas:
- if path is None: path=self.CONFIGURATION.savedir
+ if path is None: path=self.maConfiguration.savedir
bOK, fn=self.determineNomFichier(path,extension)
if bOK == 0 : return (0, None)
if fn == None : return (0, None)
if fn== '' : return (0, None)
ulfile = os.path.abspath(six.text_type(fn))
- self.appliEficas.CONFIGURATION.savedir=os.path.split(ulfile)[0]
+ self.appliEficas.maConfiguration.savedir=os.path.split(ulfile)[0]
fn = six.text_type(QDir.toNativeSeparators(fn))
newName = fn
@@ -1305,12 +1334,28 @@ class JDCEditor(Ui_baseWidget,QWidget):
if newName is not None:
self.appliEficas.addToRecentList(newName)
self.tree.racine.item.getObject().nom=os.path.basename(newName)
- self.tree.racine.update_node_label()
+ self.tree.racine.updateNodeLabel()
+
+ print ('Attention chgt du if pour test')
+ print (self.generator)
- if self.jdc.isvalid() != 0 and hasattr(self.generator, "writeDefault"):
+ #if self.jdc.isValid() != 0 and hasattr(self.generator, "writeDefault"):
+ if hasattr(self.generator, "writeDefault"):
self.generator.writeDefault(fn)
elif self.code=="TELEMAC" and hasattr(self.generator, "writeDefault"):
- self.generator.writeDefault(fn)
+ msgBox = QMessageBox(None)
+ msgBox.setWindowTitle(tr("Fichier Cas invalide"))
+ msgBox.setText(tr("Le fichier cas est invalide"))
+ msgBox.addButton(tr("&Sauvegarder"),1)
+ msgBox.addButton(tr("&Quitter sans sauvegarder"),0)
+ msgBox.addButton(tr("&Annuler"),2)
+ res=msgBox.exec_()
+ if res == 0 :
+ self.generator.writeDefault(fn)
+ return (1, self.fichier)
+ if res == 2 : return (0, None)
+ if self.appliEficas.salome : self.appliEficas.close()
+ else : sys.exit(1)
if self.salome :
self.appliEficas.addJdcInSalome( self.fichier)
@@ -1346,7 +1391,7 @@ class JDCEditor(Ui_baseWidget,QWidget):
#---------------------------------------------#
- def get_file(self,unite=None,fic_origine = ''):
+ def getFile(self,unite=None,fic_origine = ''):
#---------------------------------------------#
# appele par I_JDC
ulfile = None
@@ -1367,18 +1412,18 @@ class JDCEditor(Ui_baseWidget,QWidget):
QMessageBox.information( self, titre,texte)
fn = QFileDialog.getOpenFileName(self.appliEficas,
titre,
- self.appliEficas.CONFIGURATION.savedir)
+ self.appliEficas.maConfiguration.savedir)
- # ce retour est impose par le get_file d'I_JDC
+ # ce retour est impose par le getFile d'I_JDC
if fn== '' : return None," "
if not fn : return (0, " ")
fn=fn[0]
ulfile = os.path.abspath(six.text_type(fn))
- self.appliEficas.CONFIGURATION.savedir=os.path.split(ulfile)[0]
+ self.appliEficas.maConfiguration.savedir=os.path.split(ulfile)[0]
# On utilise le convertisseur defini par format_fichier
- source=self.get_source(ulfile)
+ source=self.getSource(ulfile)
if source:
# On a reussia convertir le fichier self.ulfile
jdcText = source
@@ -1395,7 +1440,7 @@ class JDCEditor(Ui_baseWidget,QWidget):
etape=monItem.item.object
CONTEXT.set_current_step(etape)
etape.build_includeInclude(texte)
- self.tree.racine.build_children()
+ self.tree.racine.buildChildren()
#-----------------------------------#
def updateJdcEtape(self, itemApres,texte):
@@ -1412,7 +1457,7 @@ class JDCEditor(Ui_baseWidget,QWidget):
QMessageBox.information( self,
tr("Import texte"),
tr("Impossible d importer le texte"))
- self.tree.racine.build_children()
+ self.tree.racine.buildChildren()
return ok
@@ -1421,7 +1466,7 @@ class JDCEditor(Ui_baseWidget,QWidget):
def deleteEtape(self,etape):
#-------------------------------------#
# dans le JDC
- self.jdc.suppentite(etape)
+ self.jdc.suppEntite(etape)
#-------------------------------------#
def deleteMC(self,etape,MCFils,listeAvant=()):
@@ -1431,9 +1476,9 @@ class JDCEditor(Ui_baseWidget,QWidget):
for mot in listeAvant :
ouChercher=ouChercher.get_child(mot,restreint="oui")
monMC=ouChercher.get_child(MCFils,restreint="oui")
- if monMC != None : ouChercher.suppentite(monMC)
+ if monMC != None : ouChercher.suppEntite(monMC)
ouChercher.state='changed'
- ouChercher.isvalid()
+ ouChercher.isValid()
#-------------------------------------#
def ajoutMC(self,etape,MCFils,valeurs,listeAvant=()):
@@ -1443,11 +1488,11 @@ class JDCEditor(Ui_baseWidget,QWidget):
for mot in listeAvant :
ouChercher=ouChercher.get_child(mot,restreint="oui")
monMC=etape.get_child(ouChercher,restreint="oui")
- if monMC== None : monMC= ouChercher.addentite(MCFils)
+ if monMC== None : monMC= ouChercher.addEntite(MCFils)
monMC.valeur=valeurs
monMC.val=valeurs
monMC.state='changed'
- monMC.isvalid()
+ monMC.isValid()
#----------------------------------------------#
def ajoutMCFact(self,etape,MCFils,listeAvant=()):
@@ -1461,8 +1506,8 @@ class JDCEditor(Ui_baseWidget,QWidget):
print (mot)
print (ouChercher)
monMC=etape.get_child(ouChercher,restreint="oui")
- if monMC== None : monMC= ouChercher.addentite(MCFils)
- monMC.isvalid()
+ if monMC== None : monMC= ouChercher.addEntite(MCFils)
+ monMC.isValid()
#-------------------------------------------------#
def getValeur(self,nomEtape,MCFils,listeAvant=()):
@@ -1497,8 +1542,8 @@ class JDCEditor(Ui_baseWidget,QWidget):
#print (mot, ouChercher)
if ouChercher==None : return None
monMC=ouChercher.get_child(MCFils,restreint="oui")
- monMC.set_valeur(valeur)
- monMC.isvalid()
+ monMC.setValeur(valeur)
+ monMC.isValid()
#-----------------------------------------------------------#
def changeIntoMC(self,etape,MCFils,valeurs, listeAvant=()):
@@ -1515,13 +1560,13 @@ class JDCEditor(Ui_baseWidget,QWidget):
ouChercher=ouChercher.get_child(mot,restreint="oui")
if ouChercher==None : return
monMC=ouChercher.get_child(MCFils,restreint="oui")
- if monMC== None : monMC= ouChercher.addentite(MCFils)
+ if monMC== None : monMC= ouChercher.addEntite(MCFils)
monMC.definition.into=valeurs
from Noyau.N_VALIDATOR import IntoProtocol
monMC.definition.intoProto = IntoProtocol("into", into=monMC.definition.into, val_min=monMC.definition.val_min, val_max=monMC.definition.val_max)
monMC.state='changed'
- monMC.isvalid()
+ monMC.isValid()
#-------------------------------------------------------------------#
def reCalculeValiditeMCApresChgtInto(self,nomEtape,MCFils,listeAvant=()):
@@ -1656,8 +1701,8 @@ class JDCEditor(Ui_baseWidget,QWidget):
nouveauFact=A_FACT.FACT(**args)
nouveauFact.pere=ouChercher
nouveauFact.nom=nomDuMC
- from Editeur.autre_analyse_cata import traite_entite
- traite_entite(nouveauFact,[])
+ from Editeur.autre_analyse_cata import traiteEntite
+ traiteEntite(nouveauFact,[])
ouChercher.entites[nomDuMC]=nouveauFact
ouChercher.ordre_mc.append(nomDuMC)
self.dicoNouveauxFact[nomDuMC]=('ajoutDefinitionMC',nomEtape,listeAvant,nomDuMC,listeMC,args)
@@ -1683,13 +1728,13 @@ class JDCEditor(Ui_baseWidget,QWidget):
if ouChercher==None : return
MCFils=listeMC[-1]
monMC=ouChercher.get_child(MCFils,restreint="oui")
- if monMC== None : monMC= etape.addentite(MCFils)
+ if monMC== None : monMC= etape.addEntite(MCFils)
monMC.definition.into=into
monMC.valeur=valeurs
monMC.val=valeurs
monMC.state='changed'
- monMC.isvalid()
+ monMC.isValid()
#-------------------------------------#
def ajoutVersionCataDsJDC(self,txt):
@@ -1733,7 +1778,7 @@ class JDCEditor(Ui_baseWidget,QWidget):
#------------------------------#
- def verifieCHECKSUM(self,text):
+ def verifieChecksum(self,text):
#------------------------------#
indexDeb=text.find("#CHECKSUM:")
if indexDeb < 0 :
@@ -1742,7 +1787,7 @@ class JDCEditor(Ui_baseWidget,QWidget):
checkAvant=text[indexDeb:indexFin+13]
textJDC=text[0:indexDeb]+text[indexFin+13:-1]
if self.code != 'PSEN' and self.code != 'PSEN_N1':
- checksum=self.get_checksum(textJDC)
+ checksum=self.getChecksum(textJDC)
pareil=(checkAvant==checksum)
else :
pareil=1
@@ -1750,7 +1795,7 @@ class JDCEditor(Ui_baseWidget,QWidget):
return pareil, textJDC
#---------------------------#
- def get_checksum(self,texte):
+ def getChecksum(self,texte):
#---------------------------#
newtexte=texte.replace('"','\\"')
commande='echo "'+newtexte+'"|md5sum'
@@ -1836,22 +1881,22 @@ class JDCEditor(Ui_baseWidget,QWidget):
#---------------------------#
- def BoutonFileSelected(self):
+ #def boutonFileSelected(self):
#---------------------------#
- QSfichier=self.openfile.selectedFiles()[0]
- self.fichierMED=str(QSfichier)
- from acquiertGroupes import getGroupes
- erreur,self.listeGroupes,self.nomMaillage=getGroupes(self.fichierMED)
- if erreur != "" : print ("a traiter")
+ # QSfichier=self.openfile.selectedFiles()[0]
+ # self.fichierMED=str(QSfichier)
+ # from acquiertGroupes import getGroupes
+ # erreur,self.listeGroupes,self.nomMaillage=getGroupes(self.fichierMED)
+ # if erreur != "" : print ("a traiter")
#-----------------------------
- def BoutonSalomePressed(self):
+ #def boutonSalomePressed(self):
#----------------------------
- Msg,self.listeGroupes=self.appliEficas.ChercheGrpMailleInSalome()
- self.fichierMED="A_partir_de_SMESH"
- self.nomMaillage="A_partir_de_SMESH"
- self.openfile.close()
+ # Msg,self.listeGroupes=self.appliEficas.ChercheGrpMailleInSalome()
+ # self.fichierMED="A_partir_de_SMESH"
+ # self.nomMaillage="A_partir_de_SMESH"
+ # self.openfile.close()
#-----------------------------------------
@@ -1954,26 +1999,4 @@ class JDCEditor(Ui_baseWidget,QWidget):
return indexNoeud
if __name__ == "__main__":
- self.code='ASTER'
- name='prefs_'+prefs.code
- prefsCode=__import__(name)
-
-
- if hasattr(prefsCode,'encoding'):
- # Hack pour changer le codage par defaut des strings
- import sys
- reload(sys)
- sys.setdefaultencoding(prefs.encoding)
- del sys.setdefaultencoding
- # Fin hack
-
-# code=options.code
-#
- app = QApplication(sys.argv)
- mw = JDCEditor(None,'azAster.comm')
- app.setMainWidget(mw)
- app.connect(app, SIGNAL("lastWindowClosed()"), app, SLOT("quit()"))
- mw.show()
-
- res = app.exec_loop()
- sys.exit(res)
+ print ('in main')
diff --git a/InterfaceQT4/eficas_go.py b/InterfaceQT4/eficas_go.py
index 355d3329..0d510033 100755
--- a/InterfaceQT4/eficas_go.py
+++ b/InterfaceQT4/eficas_go.py
@@ -51,7 +51,19 @@ def lance_eficas(code=None,fichier=None,ssCode=None,multi=False,langue='en'):
from InterfaceQT4.qtEficas import Appli
app = QApplication(sys.argv)
+
+ #import cProfile, pstats, StringIO
+ #pr = cProfile.Profile()
+ #pr.enable()
+
Eficas=Appli(code=code,salome=0,ssCode=ssCode,multi=multi,langue=langue)
+ #pr.disable()
+ #s = StringIO.StringIO()
+ #sortby = 'cumulative'
+ #ps = pstats.Stats(pr, stream=s).sort_stats(sortby)
+ #ps.print_stats()
+ #print (s.getvalue())
+
Eficas.show()
res=app.exec_()
@@ -84,9 +96,9 @@ def lance_eficas_ssIhm(code=None,fichier=None,ssCode=None,version=None,debug=Fal
monEditeur=JDCEditor(Eficas,fichier)
return monEditeur
-def lance_eficas_ssIhm_cherche_Groupes(code=None,fichier=None,ssCode=None,version=None):
+def lance_eficas_ssIhm_chercheGroupes(code=None,fichier=None,ssCode=None,version=None):
monEditeur=lance_eficas_ssIhm(code,fichier,ssCode,version)
- print((monEditeur.cherche_Groupes()))
+ print((monEditeur.chercheGroupes()))
def lance_eficas_ssIhm_cherche_cr(code=None,fichier=None,ssCode=None,version=None):
monEditeur=lance_eficas_ssIhm(code,fichier,ssCode,version)
diff --git a/InterfaceQT4/feuille.py b/InterfaceQT4/feuille.py
index 8b790bf0..2f5ac826 100644
--- a/InterfaceQT4/feuille.py
+++ b/InterfaceQT4/feuille.py
@@ -27,7 +27,7 @@ import types,os
import traceback
from PyQt5.QtWidgets import QToolButton ,QWidget
-from PyQt5.QtGui import QFont, QFontMetrics
+from PyQt5.QtGui import QFont, QFontMetrics, QFontInfo, QPalette
from PyQt5.QtCore import Qt
from Extensions.i18n import tr
@@ -36,7 +36,8 @@ from .gereIcones import ContientIcones
from .gereIcones import FacultatifOuOptionnel
from .qtSaisie import SaisieValeur
-nomMax=250
+nomMax=230
+# empirique les metrics ne fonctionnent pas
# ---------------------------------------------------------------------- #
class Feuille(QWidget,ContientIcones,SaisieValeur,FacultatifOuOptionnel):
# --------------------------------------------------------------------- #
@@ -76,25 +77,34 @@ class Feuille(QWidget,ContientIcones,SaisieValeur,FacultatifOuOptionnel):
self.setIconesFichier()
self.setIconesSalome()
self.setIconesGenerales()
- self.setCommentaire()
+ #self.setCommentaire()
self.setZoneInfo()
def setNom(self):
self.debutToolTip=""
nomTraduit=tr(self.objSimp.nom)
+ #metrix= QFontMetrics(self.label.font())
+ #maxLongueur = self.label.width() - 2
+ #print ('______________________')
+ #print (nomTraduit)
+ #print (self.label.font().pixelSize())
+ #longueur2 = metrix.boundingRect(nomTraduit).width()
longueur=QFontMetrics(self.label.font()).width(nomTraduit)
if longueur >= nomMax :
nouveauNom=self.formate(nomTraduit)
self.label.setText(nouveauNom)
else :
self.label.setText(nomTraduit)
+ #clidedText = metrics.elidedText(text, Qt.ElideRight, label.width());
+ #if (clippedText != nomTraduit): self.label.setToolTip(nomTraduit)
+ #self.label.setText(clippedText)
- def agrandit(self):
+ #def agrandit(self):
# inutile pour certains widgets
- if self.height() < 40 :
- self.setMinimumHeight(50)
- self.resize(self.width(),200)
+ # if self.height() < 40 :
+ # self.setMinimumHeight(50)
+ # self.resize(self.width(),200)
#def mousePressEvent(self, event):
#print 'mousePressEvent'
@@ -136,7 +146,6 @@ class Feuille(QWidget,ContientIcones,SaisieValeur,FacultatifOuOptionnel):
commentaire=tr("Entrez entre ")+"\n"+str(mc.min)+(" et ")+str(mc.max) +" " +tr(d_aides[type])+'\n'
aideval=self.node.item.aide()
commentaire=commentaire + tr(aideval)
- self.monCommentaireLabel.setText(str(commentaire))
return str(commentaire)
@@ -149,13 +158,13 @@ class Feuille(QWidget,ContientIcones,SaisieValeur,FacultatifOuOptionnel):
c = self.debutToolTip
#if self.node.item.definition.validators : c+=self.node.item.definition.validators.aide()
self.aide=c
- if self.objSimp.get_fr() != None and self.objSimp.get_fr() != "":
- #c2 = ''+c+self.objSimp.get_fr().decode('latin-1','replace')+"
"
- c2 = '