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
"""
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
""" 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 :
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
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 = ''
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
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
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):
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
# 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()
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:
"""
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
# 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()
"""
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:
# 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'):
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':
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:
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
# 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:
value = getattr(self.object, key)
except AttributeError:
continue
- item = make_objecttreeitem(
+ item = makeObjecttreeitem(
self.appli,
str(key) + " =",
value,
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) :
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)
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)
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")
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']
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':
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()
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)
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:
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):
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):
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)
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
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:
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:
""" 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)
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')")
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 $"
#
self.lignes=[]
self.fichier=fichier
self.ouvrir_fichier()
- self.constr_list_txt_cmd()
+ self.constrListTxtCmd()
def ouvrir_fichier(self):
try :
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)):
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)
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
"""
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
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
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
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__)
self.first.append(comment)
self.reglesUtilisees=[]
self.validatorsUtilises=[]
- self.constr_list_txt_cmd()
+ self.constrListTxtCmd()
self.ecrire_fichier()
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:
- 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
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]
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)
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):
# 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=[]
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):
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:
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
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
%(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)
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",
return parser
def parse(args):
- parser=create_parser()
+ parser=createParser()
(options,args)=parser.parse_args(args[1:])
if not hasattr(options,"studies"):
options.studies=[]
#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
...]
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
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
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())
#print niveau.dict_groupes
else:
for niv in niveau.l_niveaux:
- traite_niveau(niv)
+ traiteNiveau(niv)
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())
else:
# Le catalogue de commandes contient des definitions de niveau
for niv in cata.JdC.l_niveaux:
- traite_niveau(niv)
+ traiteNiveau(niv)
#self.appel = N_utils.callee_where(niveau=2)
if reg=='oui' : self.register()
- def isvalid(self):
+ def isValid(self):
return 1
def report(self):
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):
# 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
"""
"""
self.parent.register(self)
- def isoblig(self):
+ def isOblig(self):
"""
Indique si self est obligatoire ou non : retourne toujours 0
"""
"""
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)
"""
else :
return None
- def get_fr(self):
+ def getFr(self):
"""
Retourne l'attribut fr de self.definition
"""
except:
return ''
- def liste_mc_presents(self):
+ def listeMcPresents(self):
return []
def supprime(self):
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 :
- 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()
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):
"""
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
"""
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
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
"""
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
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
"""
self.actif = 1
- def isactif(self):
+ def isActif(self):
"""
Booleenne qui retourne 1 si self est valide, 0 sinon
"""
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
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):
"""
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
"""
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
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=[]
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)
- 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
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
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
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
"""
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
"""
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
"""
# 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
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
"""
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)
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':
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)
# 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
# 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
# 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
# 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
"""
# 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
"""
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 :
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
"""
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 :
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
"""
# 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:
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)
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
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)
"""
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()
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)
# 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).
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:
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.
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:
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):
"""
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):
"""
# 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
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
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
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
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()
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
"""
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):
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):
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
# 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.
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.
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
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
"""
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)
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
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
# 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:
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
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 :
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):
"""
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
"""
"""
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
"""
"""
return self.nom
- def get_sdprods(self,nom_sd):
+ def getSdprods(self,nom_sd):
"""
Retourne les concepts produits par la commande
"""
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):
"""
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
"""
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):
def __repr__(self):
return self.chainevaleur
- def isvalid(self):
+ def isValid(self):
if self.valeur and self.chainevaleur:
return 1
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
# 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()
"""
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
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
"""
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.
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
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
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 :
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
"""
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
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
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)
#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()
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
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)
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
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=[]
self.children = []
self.childrenComplete = []
- sublist = self.item._GetSubList()
+ sublist = self.item._getSubList()
ind=0
for item in sublist :
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:
# (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:
"""
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:
"""
Ajoute un commentaire a l'interieur du JDC :
"""
- self.editor.init_modif()
+ self.editor.initModif()
if after:
pos = 'after'
else:
"""
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 )
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
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
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)
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':
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) :
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 :
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())
"""
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()
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
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
# #------------------------------------------------------------------
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 :
# 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):
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'):
"""
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)) :
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
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
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
#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
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
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)
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
"""
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
"""
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 :
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' )
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
"""
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 :
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()
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
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"
# keys=self.object.mc_dict
# return keys
- def GetSubList(self):
+ def getSubList(self):
"""
Reactualise la liste des items fils stockes dans self.sublist
"""
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
- 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
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
# 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:
# 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
"""
pass
return args
- def get_corps(self):
+ def getCorps(self):
"""
Retourne le corps de la FORMULE
"""
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 :
- 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
# 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
typeNode.PopUpMenuRacine.createPopUpMenu(self)
def addParameters(self,apres):
- param=self.append_child("PARAMETRE",pos=0)
+ param=self.appendChild("PARAMETRE",pos=0)
return param
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"
# 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 :
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
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
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)
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
# ------------------------------------
-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
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
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):
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):
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)
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
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):
"""
"""
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'))
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)
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)
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)
"""
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()
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:
# 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=[]
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
"""
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
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
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
"""
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
else :
return texte[0:24]+'...'
- def GetSubList(self):
+ def getSubList(self):
"""
Retourne la liste des fils de self
"""
# 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
"""
# 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()
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)
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)
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 :
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)
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)
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
# 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)
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)
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 :
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:
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:
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:
# 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) :
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
#--------------------------------------------------
# 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
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]) :
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:
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:
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:
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:
- 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:
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:
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
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
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
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 :
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:
# 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
else :
self.rep_user = os.path.join('C:/','.config/Eficas',appli.code)
-
self.setValeursParDefaut()
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)
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
self.simpleClic= False
self.afficheOptionnelVide=False
self.afficheListesPliees=True
+ self.boutonDsMenuBar=False
+ self.ficIcones=None
+ self.repIcones=None
+ self.differencieSiDefaut=True
+
#--------------------------------------
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
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
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
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
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 :
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 :
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
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()
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']()
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']:
###
return dico
- #return self.get_Dico()
+ #return self.getDico()
#-------------------# Pour execution avec output et error dans le bash
def process_VP(self):
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
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)
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:
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()
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:
# 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"))
#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))
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
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
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
#-----------------------#
def viewJdcPy(self):
#-----------------------#
- strSource = str( self.get_text_JDC(self.format) )
+ strSource = str( self.getTextJDC(self.format) )
self._viewText(strSource, "JDC_RESULTAT")
#-----------------------#
#-----------------------#
def viewJdcRegles(self):
#-----------------------#
- if self.tree :self.tree.AppelleBuildLBRegles()
+ if self.tree :self.tree.appellebuildLBRegles()
#----------------#
self.close()
#----------------------------------------------#
- def affiche_infos(self,message,couleur=Qt.black):
+ def afficheInfos(self,message,couleur=Qt.black):
#----------------------------------------------#
if self.sb:
mapalette=self.sb.palette()
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)
self.labelCommentaire.setText("")
#-------------------#
- def init_modif(self):
+ def initModif(self):
#-------------------#
"""
Met l'attribut modified a 'o' : utilise par Eficas pour savoir
"""
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
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
# 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:
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):
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")
fichier = QFileDialog.getOpenFileName(self.appliEficas,
tr('Ouvrir Fichier'),
- self.appliEficas.CONFIGURATION.savedir,
+ self.appliEficas.maConfiguration.savedir,
tr('Wrapper Files (*.xml);;''All Files (*)'))
return fichier
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:
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
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:
# 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:
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']()
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 ""
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 :
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
#-------------------#
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
#-------------------#
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)
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")
)
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=""
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)
#-----------------------------------------#
- 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
#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)
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
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)
#---------------------------------------------#
- def get_file(self,unite=None,fic_origine = ''):
+ def getFile(self,unite=None,fic_origine = ''):
#---------------------------------------------#
# appele par I_JDC
ulfile = None
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
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):
QMessageBox.information( self,
tr("Import texte"),
tr("Impossible d importer le texte"))
- self.tree.racine.build_children()
+ self.tree.racine.buildChildren()
return ok
def deleteEtape(self,etape):
#-------------------------------------#
# dans le JDC
- self.jdc.suppentite(etape)
+ self.jdc.suppEntite(etape)
#-------------------------------------#
def deleteMC(self,etape,MCFils,listeAvant=()):
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=()):
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=()):
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=()):
#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=()):
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=()):
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)
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):
#------------------------------#
- def verifieCHECKSUM(self,text):
+ def verifieChecksum(self,text):
#------------------------------#
indexDeb=text.find("#CHECKSUM:")
if indexDeb < 0 :
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
return pareil, textJDC
#---------------------------#
- def get_checksum(self,texte):
+ def getChecksum(self,texte):
#---------------------------#
newtexte=texte.replace('"','\\"')
commande='echo "'+newtexte+'"|md5sum'
#---------------------------#
- 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()
#-----------------------------------------
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')
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_()
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)
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
from .gereIcones import FacultatifOuOptionnel
from .qtSaisie import SaisieValeur
-nomMax=250
+nomMax=230
+# empirique les metrics ne fonctionnent pas
# ---------------------------------------------------------------------- #
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'
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)
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 = '<html><head/><body><p>'+c+self.objSimp.get_fr().decode('latin-1','replace')+"</p></body></html>"
- c2 = '<html><head/><body><p>'+c+self.objSimp.get_fr()
- #c2 = '<html><head/><body><p>'+c+self.objSimp.get_fr()+"</p></body></html>"
+ if self.objSimp.getFr() != None and self.objSimp.getFr() != "":
+ #c2 = '<html><head/><body><p>'+c+self.objSimp.getFr().decode('latin-1','replace')+"</p></body></html>"
+ c2 = '<html><head/><body><p>'+c+self.objSimp.getFr()
+ #c2 = '<html><head/><body><p>'+c+self.objSimp.getFr()+"</p></body></html>"
self.label.setToolTip(c2)
- #self.aide=self.objSimp.get_fr().decode('latin-1','ignore')+" "+c
- self.aide=self.objSimp.get_fr()+" "+c
+ #self.aide=self.objSimp.getFr().decode('latin-1','ignore')+" "+c
+ self.aide=self.objSimp.getFr()+" "+c
else :
c+=self.finCommentaire()
if c != "" and c != None :
def setZoneInfo(self):
# info=str(self.nom)+' '
- # if self.monSimpDef.get_fr() != None and self.monSimpDef.get_fr() != "": info+=self.monSimpDef.get_sug() +" "
+ # if self.monSimpDef.getFr() != None and self.monSimpDef.getFr() != "": info+=self.monSimpDef.get_sug() +" "
# if self.monSimpDef.get_sug() != None and self.monSimpDef.get_sug() != "": info+="Valeur suggeree : "self.monSimpDef.get_sug()
pass
#nodeAVoir.fenetre.setFocus()
# return # on est bien postionne
- if self.objSimp.isvalid() and hasattr(self, 'AAfficher'):
+ if self.objSimp.isValid() and hasattr(self, 'AAfficher'):
nodeAVoir=self.parentQt.node.chercheNoeudCorrespondant(self.objSimp)
try :
index=self.editor.fenetreCentraleAffichee.listeAffichageWidget.index(nodeAVoir.fenetre.AAfficher)
except :
pass
else :
- if self.objSimp.isvalid() and hasattr(self, 'AAfficher'):
+ if self.objSimp.isValid() and hasattr(self, 'AAfficher'):
try :
self.setValeursApresBouton()
except :
# QWidget.enterEvent(self,event)
def traiteClicSurLabel(self,texte):
- aide=self.aide.encode('latin-1', 'ignore').decode('latin-1')+"\n"+self.aideALaSaisie().encode('latin-1', 'ignore').decode('latin-1')
- self.editor.affiche_commentaire(aide)
+ #aide=self.aide.encode('latin-1', 'ignore').decode('latin-1')+"\n"+self.aideALaSaisie().encode('latin-1', 'ignore').decode('latin-1')
+ try :
+ aide=self.aide+"\n"+self.aideALaSaisie()
+ except :
+ aide=self.aideALaSaisie()
+ self.editor.afficheCommentaire(aide)
def formate(self,t):
- if t.find('_')==0 :
- newText=t[0:19]+'\n'+t[19:]
- else:
- listeNom=t.split('_')
- newTexte=""
- ligne=""
- for n in listeNom:
- if len(ligne)+len(n) < 25 :
- newTexte=newTexte+"_"+n
- ligne+="_"+n
- else :
- newTexte=newTexte+"\n_"+n
- ligne=""
- #newTexte=t[0:t.rfind('_')]+'\n'+ t[t.rfind('_'):]
- newText=newTexte[1:]
+ l=len(t)//2
+ newText=t[0:l]+'-\n'+t[l:]
return newText
def setReglesEtAide(self):
listeRegles=()
try :
- listeRegles = self.node.item.get_regles()
+ listeRegles = self.node.item.getRegles()
except :
pass
if hasattr(self,"RBRegle"):
if isinstance(self,MonWidgetCommande) and self.editor.code =="MAP":
self.cle_doc = self.chercheDocMAP()
else :
- self.cle_doc = self.node.item.get_docu()
+ self.cle_doc = self.node.item.getDocu()
if self.cle_doc == None : self.RBInfo.close()
else : self.RBInfo.clicked.connect (self.viewDoc)
def chercheDocMAP(self):
try :
- clef=self.editor.CONFIGURATION.adresse+"/"
+ clef=self.editor.maConfiguration.adresse+"/"
except :
return None
for k in self.editor.readercata.cata[0].JdC.dict_groupes:
QMessageBox.warning( self,tr( "Aide Indisponible"),tr( "l'aide n est pas installee "))
def viewRegles(self):
- self.node.AppelleBuildLBRegles()
+ self.node.appellebuildLBRegles()
def setIconePoubelle(self):
if not(hasattr(self,"RBPoubelle")):return
- if self.node.item.object.isoblig() and not( hasattr(self.node.item.object,'isDeletable') ):
+ if self.node.item.object.isOblig() and not( hasattr(self.node.item.object,'isDeletable') ):
icon=QIcon(self.repIcon+"/deleteRondVide.png")
self.RBPoubelle.setIcon(icon)
return
def setValide(self):
#print " c est le moment de gerer le passage au suivant"
if not(hasattr (self,'RBValide')) : return
- icon = QIcon()
- if self.node.item.object.isvalid() :
- icon=QIcon(self.repIcon+"/ast-green-ball.png")
- else :
- icon=QIcon(self.repIcon+"/ast-red-ball.png")
- self.RBValide.setIcon(icon)
+ couleur=self.node.item.getIconName()
+ if not self.editor.maConfiguration.differencieSiDefaut and couleur == 'ast-green-dark-ball' : couleur="ast-green-ball"
+ monIcone = QIcon(self.repIcon+"/" + couleur + ".png")
+ self.RBValide.setIcon(monIcone)
# il faut chercher la bonne fenetre
def rendVisible(self):
if len(mctype) > 2 and mctype[2] == "Sauvegarde":
fichier = QFileDialog.getSaveFileName(self.appliEficas,
tr('Sauvegarder Fichier'),
- self.appliEficas.CONFIGURATION.savedir,
+ self.appliEficas.maConfiguration.savedir,
filters)
else:
print(filters)
fichier = QFileDialog.getOpenFileName(self.appliEficas,
tr('Ouvrir Fichier'),
- self.appliEficas.CONFIGURATION.savedir,
+ self.appliEficas.maConfiguration.savedir,
filters)
fichier=fichier[0]
if not(fichier == ""):
ulfile = os.path.abspath(six.text_type(fichier))
- self.appliEficas.CONFIGURATION.savedir=os.path.split(ulfile)[0]
+ self.appliEficas.maConfiguration.savedir=os.path.split(ulfile)[0]
self.lineEditVal.setText(fichier)
- self.editor.affiche_commentaire(tr("Fichier selectionne"))
- self.LEValeurPressed()
+ self.editor.afficheCommentaire(tr("Fichier selectionne"))
+ self.LEvaleurPressed()
if (QFileInfo(fichier).suffix() in listeSuffixe ):
self.image=fichier
if (not hasattr(self,"BSelectInFile")):
self.file_dialog.exec_()
if self.fileName == "" : return
self.lineEditVal.setText(self.fileName)
- self.LEValeurPressed()
+ self.LEvaleurPressed()
def explore(self,widget):
def BRepertoirePressed(self):
directory = QFileDialog.getExistingDirectory(self.appliEficas,
- directory = self.appliEficas.CONFIGURATION.savedir,
+ directory = self.appliEficas.maConfiguration.savedir,
options = QFileDialog.ShowDirsOnly)
if not (directory == "") :
absdir = os.path.abspath(six.text_type(directory))
- self.appliEficas.CONFIGURATION.savedir = os.path.dirname(absdir)
+ self.appliEficas.maConfiguration.savedir = os.path.dirname(absdir)
self.lineEditVal.setText(directory)
- self.LEValeurPressed()
+ self.LEvaleurPressed()
def BSelectInFilePressed(self):
from monSelectImage import MonSelectImage
def BSalomePressed(self):
- self.editor.affiche_commentaire("")
+ self.editor.afficheCommentaire("")
selection=[]
commentaire=""
- genea=self.node.item.get_genealogie()
+ genea=self.node.item.getGenealogie()
kwType = self.node.item.get_definition().type[0]
for e in genea:
if "GROUP_NO" in e: kwType = "GROUP_NO"
selection, commentaire = self.appliEficas.selectEntryFromSalome(kwType,editor=self.editor)
if commentaire !="" :
- self.editor.affiche_infos(tr(str(commentaire)))
+ self.editor.afficheInfos(tr(str(commentaire)))
if selection == [] : return
- min,max=self.node.item.GetMinMax()
+ min,max=self.node.item.getMinMax()
if max > 1 :
self.ajoutNValeur(selection)
return
for geomElt in selection: monTexte=geomElt+","
monTexte= monTexte[0:-1]
self.lineEditVal.setText(str(monTexte))
- self.LEValeurPressed()
+ self.LEvaleurPressed()
def BView2DPressed(self):
try :
if valeur :
ok, msgError = self.appliEficas.displayShape(valeur)
if not ok:
- self.editor.affiche_infos(msgError,Qt.red)
+ self.editor.afficheInfos(msgError,Qt.red)
def BParametresPressed(self):
- liste=self.node.item.get_liste_param_possible()
+ liste=self.node.item.getListeParamPossible()
from monListeParamPanel import MonListeParamPanel
MonListeParamPanel(liste=liste,parent=self).show()
def __init__(self):
self.connecterSignaux()
- def connecterSignauxQT4(self):
- if hasattr(self,'RBHaut'):
- self.connect(self.RBHaut,SIGNAL("clicked()"),self.hautPushed)
- self.connect(self.RBBas,SIGNAL("clicked()"),self.basPushed)
- self.connect(self.RBMoins,SIGNAL("clicked()"),self.moinsPushed)
- self.connect(self.RBPlus,SIGNAL("clicked()"),self.plusPushed)
- self.connect(self.RBVoisListe,SIGNAL("clicked()"),self.voisListePushed)
- if hasattr(self,'PBAlpha'):
- self.connect(self.PBAlpha,SIGNAL("clicked()"),self.alphaPushed)
- self.connect(self.PBCata,SIGNAL("clicked()"),self.cataPushed)
- self.connect(self.PBFind,SIGNAL("clicked()"),self.findPushed)
- self.connect(self.LEFiltre,SIGNAL("returnPressed()"),self.LEFiltreReturnPressed)
def connecterSignaux(self):
if hasattr(self,'RBHaut'):
def plusPushed(self):
if self.indexDernierLabel == self.monSimpDef.max:
if len(self.listeValeursCourantes) < self.monSimpDef.max : self.chercheLigneVide()
- else : self.editor.affiche_infos('nb max de valeurs : '+str(self.monSimpDef.max)+' atteint',Qt.red)
+ else : self.editor.afficheInfos('nb max de valeurs : '+str(self.monSimpDef.max)+' atteint',Qt.red)
return
self.ajoutLineEdit()
self.descendLesLignes()
def voisListePushed(self):
texteValeurs=""
- for v in self.node.item.GetListeValeurs():
+ for v in self.node.item.getListeValeurs():
texteValeurs+=str(v)+", "
entete="Valeurs pour "+self.nom
f=ViewText(self,self.editor,entete,texteValeurs[0:-2])
def selectInFile(self):
- init=str( self.editor.CONFIGURATION.savedir)
+ init=str( self.editor.maConfiguration.savedir)
fn = QFileDialog.getOpenFileName(self.node.appliEficas,
tr("Fichier de donnees"),
init,
if fn == None : return
if fn == "" : return
ulfile = os.path.abspath(six.text_type(fn))
- self.editor.CONFIGURATION.savedir=os.path.split(ulfile)[0]
+ self.editor.maConfiguration.savedir=os.path.split(ulfile)[0]
from .monSelectVal import MonSelectVal
MonSelectVal(file=fn,parent=self).show()
class GereRegles(object) :
- def AppelleBuildLBRegles(self):
+ def appellebuildLBRegles(self):
from .browser import JDCTree
if isinstance(self,JDCTree):
- self.AppelleBuildLBReglesForJdC()
+ self.appellebuildLBReglesForJdC()
else :
- self.AppelleBuildLBReglesForCommand()
- self.BuildLBRegles(self.listeRegles,self.listeNomsEtapes)
- self.AfficheRegles()
+ self.appellebuildLBReglesForCommand()
+ self.buildLBRegles(self.listeRegles,self.listeNomsEtapes)
+ self.afficheRegles()
- def AppelleBuildLBReglesForCommand(self):
- self.listeRegles = self.item.get_regles()
- self.listeNomsEtapes = self.item.get_mc_presents()
+ def appellebuildLBReglesForCommand(self):
+ self.listeRegles = self.item.getRegles()
+ self.listeNomsEtapes = self.item.getMcPresents()
- def AppelleBuildLBReglesForJdC(self):
- self.listeRegles=self.item.get_regles()
- self.listeNomsEtapes = self.item.get_l_noms_etapes()
+ def appellebuildLBReglesForJdC(self):
+ self.listeRegles=self.item.getRegles()
+ self.listeNomsEtapes = self.item.getLNomsEtapes()
- def BuildLBRegles(self,listeRegles,listeNomsEtapes):
+ def buildLBRegles(self,listeRegles,listeNomsEtapes):
self.liste=[]
if len(listeRegles) > 0:
for regle in listeRegles :
if self.liste==[] : self.liste.append(("pas de regle de construction pour ce jeu de commandes",Qt.black))
- def AfficheRegles(self):
+ def afficheRegles(self):
titre="Regles pour "+self.item.nom
w = ViewRegles( self.editor,self.liste,titre )
w.exec_()
self.listeFocus=[]
self.appliEficas=self.editor.appliEficas
self.repIcon=self.appliEficas.repIcon
- self.jdc=self.node.item.get_jdc()
+ self.jdc=self.node.item.getJdc()
self.setIconePoubelle()
self.setIconesGenerales()
self.setRun()
self.afficheMots()
self.listeMCAAjouter=[]
self.dictMCVenantDesBlocs={}
- if hasattr(self,'RBDeplie') : self.RBDeplie.clicked.connect(self.Deplie)
- if hasattr(self,'RBPlie') : self.RBPlie.clicked.connect( self.Plie)
+ if hasattr(self,'RBDeplie') : self.RBDeplie.clicked.connect(self.setDeplie)
+ if hasattr(self,'RBPlie') : self.RBPlie.clicked.connect( self.setPlie)
self.setAcceptDrops(True)
def donneFocus(self):
for fenetre in self.listeFocus:
if fenetre==None : return
- if fenetre.node.item.isvalid() == 0 :
+ if fenetre.node.item.isValid() == 0 :
fenetre.prendLeFocus=1
fenetre.hide()
fenetre.show()
def calculOptionnel(self):
self.liste_mc=[]
- genea =self.obj.get_genealogie()
+ self.liste_mc_regle=[]
+ genea =self.obj.getGenealogie()
# Attention : les mots clefs listes (+sieurs fact )
# n ont pas toutes ces methodes
try :
- self.liste_mc=self.obj.get_liste_mc_ordonnee(genea,self.jdc.cata_ordonne_dico)
+ self.liste_mc=self.obj.getListeMcOrdonnee(genea,self.jdc.cata_ordonne_dico)
+ for regle in self.obj.getRegles():
+ for mc in regle.mcs :
+ self.liste_mc_regle.append(mc)
except :
+ #print ('in except')
+ #print (self)
return
def afficheOptionnel(self):
- liste=self.ajouteMCOptionnelDesBlocs()
+ liste,liste_rouge=self.ajouteMCOptionnelDesBlocs()
self.monOptionnel=self.editor.widgetOptionnel
- self.monOptionnel.afficheOptionnel(liste,self)
+ self.monOptionnel.afficheOptionnel(liste,liste_rouge,self)
#self.monOptionnel.affiche(liste)
i=0
self.calculOptionnel()
liste=self.liste_mc
+ liste_rouge=self.liste_mc_regle
for MC in self.liste_mc : self.dictMCVenantDesBlocs[MC]=self
# ce cas est le cas machine tournant sr le plie
try :
i=i+1
if not(isinstance(widget,MonWidgetBloc)) : continue
widget.calculOptionnel()
- listeW=widget.ajouteMCOptionnelDesBlocs()
+ listeW,listeW_rouge=widget.ajouteMCOptionnelDesBlocs()
for MC in widget.dictMCVenantDesBlocs:
if MC in self.dictMCVenantDesBlocs: print ("Pb Sur les MC" )
else : self.dictMCVenantDesBlocs[MC]=widget.dictMCVenantDesBlocs[MC]
liste=liste+listeW
+ liste_rouge=liste_rouge+listeW_rouge
except :
pass
- return liste
+ return (liste,liste_rouge)
def reaffiche(self,nodeAVoir=None):
#on ajoute et on enleve
listeNode=[]
for name in listeMC :
- nodeAEnlever=self.node.append_child(name)
+ nodeAEnlever=self.node.appendChild(name)
if nodeAEnlever.item.isMCList():
nodeAEnlever=nodeAEnlever.children[-1]
listeNode.append(nodeAEnlever)
if len(listeNode) == 0 : return
if len(listeNode) == 1 :
listeNode[0].delete()
- self.editor.affiche_infos("")
+ self.editor.afficheInfos("")
return
for noeud in listeNode:
- noeud.treeParent.item.suppitem(noeud.item)
- noeud.treeParent.build_children()
- self.editor.affiche_infos("")
+ noeud.treeParent.item.suppItem(noeud.item)
+ noeud.treeParent.buildChildren()
+ self.editor.afficheInfos("")
def ajoutMC(self,texteListeNom):
listeNom=texteListeNom.split("+")[1:]
for nom in listeNom:
if nom not in self.dictMCVenantDesBlocs:
#print "bizarre, bizarre"
- self.editor.init_modif()
- nouveau=self.node.append_child(nom)
+ self.editor.initModif()
+ nouveau=self.node.appendChild(nom)
else :
- self.editor.init_modif()
+ self.editor.initModif()
widget=self.dictMCVenantDesBlocs[nom]
- nouveau=widget.node.append_child(nom)
+ nouveau=widget.node.appendChild(nom)
if firstNode==None : firstNode=nouveau
if nouveau == None or nouveau == 0 :
- self.editor.affiche_infos(tr('insertion impossible a cet endroit pour '+nom),Qt.red)
+ self.editor.afficheInfos(tr('insertion impossible a cet endroit pour '+nom),Qt.red)
self.reaffiche(firstNode)
if firstNode!=None and firstNode !=0 and firstNode.item!=None :
firstNode.select()
- def Plie(self):
+ def setPlie(self):
self.node.setPlie()
if self.editor.code== 'MT' and (self.maCommande.obj.nom == "ZONE") :
- #if (len(self.node.item.get_genealogie())==2):
+ #if (len(self.node.item.getGenealogie())==2):
index=self.maCommande.commandesLayout.indexOf(self)
self.maCommande.reafficheSeulement(self,index)
return
#print ('je reaffiche dans Plie')
self.reaffiche(self.node)
- def Deplie(self):
+ def setDeplie(self):
self.node.setDeplie()
if self.editor.code== 'MT' and (self.maCommande.obj.nom == "ZONE") :
- #if (len(self.node.item.get_genealogie())==2):
+ #if (len(self.node.item.getGenealogie())==2):
index=self.parentQt.commandesLayout.indexOf(self)
self.maCommande.reafficheSeulement(self,index)
return
#print ('je reaffiche dans Plie')
self.reaffiche(self.node)
-
- #def Plie(self):
- #print ('Deplie', self)
- #print (self.obj.nom)
- #print (self.node.setPlie)
- #print (self.parentQt)
- #print (self)
- # self.node.setPlie()
- #if self.editor.code== 'MT' and (self.maCommande.obj.nom == "ZONE") :
- # itemAtraiter = self.node.item
- # nodeAtraiter=self.node
- #while (len(itemAtraiter.get_genealogie()) > 2 ):
- # itemAtraiter=itemAtraiter.parent
- # nodeAtraiter=nodeAtraiter.vraiParent
- #ancien=nodeAtraiter.fenetre
- #panneau = nodeAtraiter.getPanelGroupe(self,self.maCommande,insertIn=False)
- #print (itemAtraiter,nodeAtraiter)
- #self.parentQt.commandesLayout.replaceWidget(ancien,panneau,Qt.FindDirectChildrenOnly)
- #nodeAtraiter.vraiParent.fenetre.commandesLayout.replaceWidget(ancien,panneau,Qt.FindDirectChildrenOnly)
- #return
- # if self.editor.code== 'MT' and (self.maCommande.obj.nom == "ZONE") :
- # if (len(self.node.item.get_genealogie())==2):
- #print (self)
- #print (self.obj.nom)
- #print (self.node.item.getlabeltext())
- #print (self.parentQt)
- #print (self.editor.fenetreCentraleAffichee)
- #print (self.maCommande)
- # index=self.parentQt.commandesLayout.indexOf(self)
- #print (index)
- # self.maCommande.reafficheSeulement(self,index)
- #self.disconnect()
- #for c in self.children():
- # print (c)
- # try :
- # c.setParent(None)
- # c.deleteLater()
- # c.close()
- # c.disconnect()
- # except :
- # print('poum')
- #panneau = self.node.getPanelGroupe(self.parentQt,self.maCommande,insertIn=False)
- # print (self.parentQt)
- # print (self)
- #self.parentQt.commandesLayout.replaceWidget(self,panneau,Qt.FindDirectChildrenOnly)
- # self.parentQt.setUpdatesEnabled(True)
- # print (dir(self.parentQt.commandesLayout))
- #self.parentQt.commandesLayout.updateGeometry()
- # else :
- # self.reaffiche(self.node)
- # return
- #print ('je reaffiche dans Plie')
- # self.reaffiche(self.node)
-#
-# def Deplie(self):
-# print ('Deplie', self)
-# print (self.obj.nom)
-# print (self.node.item.GetLabelText())
-# self.node.setDeplie()
-# #if self.editor.code== 'MT' and (self.maCommande.obj.nom == "ZONE") and (len(self.node.item.get_genealogie())==2):
-# #print (self.node.vraiParent.children)
-# #if self.editor.code== 'MT' and (self.maCommande.obj.nom == "ZONE") :
-# # itemAtraiter = self.node.item
-# # nodeAtraiter=self.node
-# # while (len(itemAtraiter.get_genealogie()) > 2 ):
-# # itemAtraiter=itemAtraiter.parent
-# # nodeAtraiter=nodeAtraiter.vraiParent
-# # ancien=nodeAtraiter.fenetre
-# # panneau = nodeAtraiter.getPanelGroupe(self,self.maCommande,insertIn=False)
-# #print (itemAtraiter,nodeAtraiter)
-# #self.parentQt.commandesLayout.replaceWidget(ancien,panneau,Qt.FindDirectChildrenOnly)
-# # nodeAtraiter.vraiParent.fenetre.commandesLayout.replaceWidget(ancien,panneau,Qt.FindDirectChildrenOnly)
-# # return
-# if self.editor.code== 'MT' and (self.maCommande.obj.nom == "ZONE") :
-# if (len(self.node.item.get_genealogie())==2):
-# #panneau = self.node.getPanelGroupe(self.parentQt,self.maCommande,insertIn=False)
-# #self.parentQt.commandesLayout.replaceWidget(self,panneau,Qt.FindDirectChildrenOnly)
-# #index=self.parentQt.commandesLayout.indexOf(self)
-# #index=self.maCommande.commandesLayout.indexOf(self)
-# #print ('index = ', index)
-# index=0
-# self.maCommande.reafficheSeulement(self,index)
-# else :
-# self.reaffiche(self.node)
-# return
-#
-# #print ('je reaffiche')
-# self.reaffiche(self.node)
def traiteClicSurLabel(self,texte):
if self.editor.code != "CARMELCND" : self.afficheOptionnel()
def mousePressEvent(self, event):
#print "dans mousePressEvent"
- if self.parent.node.item.object.isvalid() :
+ if self.parent.node.item.object.isValid() :
myToolTip=tr("objet valide")
+ if self.parent.editor.configuration.differencieSiDefaut :
+ if self.parent.node.item.object.valeur != self.parent.node.item.object.definition.defaut :
+ myToolTip+='\ndefaut : \n'+str(self.parent.node.item.object.definition.defaut)
+
QToolTip.showText(event.globalPos(),myToolTip )
else :
t=""
self.TLNb.setText(tr("%d versions du catalogue sont disponibles", len(listeCata)))
if title is not None:
self.setWindowTitle(tr(title))
+ self.buttonOk.clicked.connect(self.cataChoisi)
+ self.buttonCancel.clicked.connect(self.sortSansChoix)
- def on_buttonCancel_clicked(self):
+
+ def sortSansChoix(self):
QDialog.reject(self)
- def on_buttonOk_clicked(self):
+ def cataChoisi(self):
QDialog.accept(self)
discretes
"""
def __init__(self, parentAppli=None):
- QDialog.__init__(self,parentAppli)
+ QDialog.__init__(self,parent=parentAppli,flags=Qt.Window)
self.setModal(True)
self.setupUi(self)
self.parentAppli=parentAppli
self.verifieInstall()
self.code=None
- self.pB_OK.clicked.connect(self.choisitCode)
- self.pB_cancel.clicked.connect(self.sortie)
+ self.buttonBox.accepted.disconnect(self.accept)
+ self.buttonBox.accepted.connect(self.choisitCode)
+ # self.pB_OK.clicked.connect(self.choisitCode)
+ #self.pB_cancel.clicked.connect(self.sortie)
def sortie(self):
QDialog.reject(self)
def verifieInstall(self):
self.groupCodes=QButtonGroup(self.groupBox)
vars=list(os.environ.items())
- listeCode=('Aster','Adao','Carmel3D','CarmelCND','CF','MAP','MT','PSEN','PSEN_N1','Telemac','ZCracks',)
+ listeCode=('Adao','Carmel3D','CarmelCND','CF','MAP','MT','PSEN','PSEN_N1','Telemac','ZCracks',)
for code in listeCode:
dirCode=os.path.abspath(os.path.join(os.path.abspath(__file__),'../..',code))
try :
"""
"""
def __init__(self,node, jdc_item, editor):
- QWidget.__init__(self,None)
+ QWidget.__init__(self,parent=None)
self.setupUi(self)
self.repIcon=os.path.join( os.path.dirname(os.path.abspath(__file__)),'..','Editeur','icons')
self.item = jdc_item
self.node = node
self.editor = editor
- self.jdc = self.item.object.get_jdc_root()
+ self.jdc = self.item.object.getJdcRoot()
debutTitre=self.editor.titre
self.listeWidget=[]
self.dicoCmd={}
self.LEFiltre.returnPressed.connect(self.ajouteRadioButtons)
self.LEFiltre.textChanged.connect(self.ajouteRadioButtons)
- if self.node.tree.item.get_regles() == () :
+ if self.node.tree.item.getRegles() == () :
self.RBRegle.close()
self.labelRegle.close()
else :
self.editor.widgetOptionnel=None
self.name=None
- self.affiche_alpha=0
- self.affiche_groupe=0
- self.affiche_ordre=0
+ self.boolAlpha=0
+ self.boolGroupe=0
+ self.boolOrdre=0
if self.editor.affiche=="alpha" :
- self.affiche_alpha==1;
+ self.boolAlpha==1;
self.RBalpha.setChecked(True);
self.afficheAlpha()
elif self.editor.affiche=="groupe" :
- self.affiche_groupe==1;
+ self.boolGroupe==1;
self.RBGroupe.setChecked(True);
self.afficheGroupe()
elif self.editor.affiche=="ordre" :
- self.affiche_ordre==1;
+ self.boolOrdre==1;
self.RBOrdre.setChecked(True);
self.afficheOrdre()
if self.editor.closeFrameRechercheCommande == True : self.frameAffichage.close()
else: self.editor.restoreSplitterSizes(3)
def afficheRegle(self):
- self.node.tree.AppelleBuildLBRegles()
+ self.node.tree.appellebuildLBRegles()
def afficheAlpha(self):
- self.affiche_alpha=1
- self.affiche_groupe=0
- self.affiche_ordre=0
+ self.boolAlpha=1
+ self.boolGroupe=0
+ self.boolOrdre=0
self.ajouteRadioButtons()
def afficheGroupe(self):
- self.affiche_alpha=0
- self.affiche_groupe=1
- self.affiche_ordre=0
+ self.boolAlpha=0
+ self.boolGroupe=1
+ self.boolOrdre=0
self.ajouteRadioButtons()
def afficheOrdre(self):
- self.affiche_alpha=0
- self.affiche_groupe=0
- self.affiche_ordre=1
+ self.boolAlpha=0
+ self.boolGroupe=0
+ self.boolOrdre=1
self.ajouteRadioButtons()
def insereNoeudApresClick(self,event):
if nodeCourrant==None: nodeCourrant=self.node.tree.racine
if self.name != None :
plier=self.editor.afficheCommandesPliees
- if nodeCourrant==self.node : nouveau=self.node.append_child(self.name,'first',plier)
+ if nodeCourrant==self.node : nouveau=self.node.appendChild(self.name,'first',plier)
else : nouveau=nodeCourrant.appendBrother(self.name,plier=plier)
else :
nouveau = 0
else:
aExclure=()
listeACreer=[]
- for l in self.jdc.get_liste_cmd():
+ for l in self.jdc.getListeCmd():
if l not in aExclure :
if sensibleALaCasse and (filtre != None and not filtre in l) : continue
if (not sensibleALaCasse) and filtre != None and (not filtre in l) and (not filtre.upper() in l) : continue
w.setParent(None)
w.close()
self.listeWidget=[]
- if self.affiche_alpha==1 :
+ if self.boolAlpha==1 :
liste=self.creeListeCommande(filtre)
for cmd in liste :
self.dicoCmd[tr(cmd)]=cmd
self.buttonGroup.buttonClicked.connect(self.rbCliqueEtInsere)
else :
self.buttonGroup.buttonClicked.connect(self.rbClique)
- elif self.affiche_groupe==1 :
+ elif self.boolGroupe==1 :
listeGroupes,dictGroupes=self.jdc.get_groups()
for grp in listeGroupes:
if grp == "CACHE" : continue
label2.setText(" ")
self.listeWidget.append(label2)
self.commandesLayout.addWidget(label2)
- elif self.affiche_ordre==1 :
+ elif self.boolOrdre==1 :
listeFiltre=self.creeListeCommande(filtre)
liste=[]
if self.editor.Ordre_Des_Commandes == None : Ordre_Des_Commandes=listeFiltre
col=-1
ligne = 0
- if self.affiche_alpha==1 :
+ if self.boolAlpha==1 :
liste=self.creeListeCommande(None)
- elif self.affiche_ordre:
+ elif self.boolOrdre:
liste=self.creeListeCommande(None)
listeFiltre=self.creeListeCommande(None)
liste=[]
commentaire=getattr(definitionEtape,"ang")
except :
commentaire=""
- self.editor.affiche_commentaire(commentaire)
+ self.editor.afficheCommentaire(commentaire)
def __init__(self,node, parent = None,name = None,fl = 0):
#print "MonFonctionPanel"
self.node=node
- self.SetNbValeurs()
+ self.setNbValeurs()
MonPlusieursBasePanel.__init__(self,node,parent,name,fl)
- def SetNbValeurs(self):
+ def setNbValeurs(self):
self.nbValeurs = 1
- if self.node.item.wait_tuple()== 1 :
+ if self.node.item.waitTuple()== 1 :
for a in self.node.item.definition.type :
try :
self.nbValeurs = a.ntuple
break
except :
pass
- genea=self.node.item.get_genealogie()
+ genea=self.node.item.getGenealogie()
self.nbValeursASaisir=self.nbValeurs
if "VALE" in genea: self.nbValeurs=2
if "VALE_C" in genea: self.nbValeurs=3
- def DecoupeListeValeurs(self,liste):
+ def decoupeListeValeurs(self,liste):
#decoupe la liste des valeurs en n ( les x puis les y)
l_valeurs=[]
if ((len(liste)% self.nbValeursASaisir != 0 and (len(liste)% self.nbValeurs))):
message=tr("La cardinalite n'est pas correcte, la derniere valeur est ignoree")
- self.editor.affiche_infos(message,Qt.red)
+ self.editor.afficheInfos(message,Qt.red)
i=0
while ( i < len(liste) ) :
try :
l_valeurs.append(t)
return l_valeurs
- def BuildLBValeurs(self,listeValeurs=None):
+ def buildLBValeurs(self,listeValeurs=None):
self.LBValeurs.clear()
if listeValeurs== None :
- listeValeurs=self.node.item.GetListeValeurs()
- if self.node.item.wait_tuple()== 1 :
+ listeValeurs=self.node.item.getListeValeurs()
+ if self.node.item.waitTuple()== 1 :
listeATraiter=listeValeurs
for valeur in listeATraiter:
str_valeur=str(valeur)
self.LBValeurs.addItem(str_valeur)
else :
- for valeur in self.DecoupeListeValeurs(listeValeurs):
+ for valeur in self.decoupeListeValeurs(listeValeurs):
if type(valeur) == tuple:
TupleEnTexte="("
for val in valeur :
- TupleEnTexte = TupleEnTexte + str(self.politique.GetValeurTexte(val)) +", "
+ TupleEnTexte = TupleEnTexte + str(self.politique.getValeurTexte(val)) +", "
TupleEnTexte = TupleEnTexte[0:-2] +")"
self.LBValeurs.addItem(TupleEnTexte)
else :
# Pour etre appele a partir du Panel Importer (donc plusieurs fois par AjouterNValeur)
validite=1
if liste == [] :
- if self.node.item.wait_tuple()== 1 :
+ if self.node.item.waitTuple()== 1 :
liste=SaisieValeur.TraiteLEValeurTuple(self)
if liste == [''] : return
else :
if validite == 0 : return
if liste ==[] : return
- if (self.node.item.wait_tuple()== 1 and len(liste) != self.nbValeurs):
+ if (self.node.item.waitTuple()== 1 and len(liste) != self.nbValeurs):
commentaire = str(liste)
commentaire += tr(" n est pas un tuple de ")
commentaire += str(self.nbValeursASaisir)
commentaire += tr(" valeurs")
self.LEValeur.setText(str(liste))
- self.editor.affiche_infos(commentaire,Qt.red)
+ self.editor.afficheInfos(commentaire,Qt.red)
return
- if self.node.item.wait_tuple()== 1 :
+ if self.node.item.waitTuple()== 1 :
liste2=tuple(liste)
liste=liste2
listeVal=[]
for valeur in self.listeValeursCourantes :
listeVal.append(valeur)
- if self.node.item.wait_tuple()== 1 :
+ if self.node.item.waitTuple()== 1 :
indexListe = index
- validite,comm,comm2,listeRetour=self.politique.AjoutTuple(liste,index,listeVal)
+ validite,comm,comm2,listeRetour=self.politique.ajoutTuple(liste,index,listeVal)
else :
- validite,comm,comm2,listeRetour=self.politique.AjoutValeurs(liste,index,listeVal)
+ validite,comm,comm2,listeRetour=self.politique.ajoutValeurs(liste,index,listeVal)
self.Commentaire.setText(tr(comm2))
if not validite :
- self.editor.affiche_infos(comm,Qt.red)
+ self.editor.afficheInfos(comm,Qt.red)
else:
self.LEValeur.setText("")
l1=self.listeValeursCourantes[:indexListe]
l3=self.listeValeursCourantes[indexListe:]
- if self.node.item.wait_tuple()== 1 :
+ if self.node.item.waitTuple()== 1 :
listeATraiter=listeRetour
else :
- listeATraiter=self.DecoupeListeValeurs(listeRetour)
+ listeATraiter=self.decoupeListeValeurs(listeRetour)
for valeur in listeATraiter :
if type(valeur) == tuple:
TupleEnTexte="("
for val in valeur :
- TupleEnTexte = TupleEnTexte + str(self.politique.GetValeurTexte(val)) +", "
+ TupleEnTexte = TupleEnTexte + str(self.politique.getValeurTexte(val)) +", "
str_valeur = TupleEnTexte[0:-2] +")"
else :
str_valeur=str(valeur)
self.LBValeurs.setCurrentItem(item)
index=index+1
self.listeValeursCourantes=l1+listeRetour+l3
- self.BuildLBValeurs(self.listeValeursCourantes)
+ self.buildLBValeurs(self.listeValeursCourantes)
def ajoutNValeur(self,liste) :
if len(liste)%self.nbValeurs != 0 :
texte="Nombre de valeur incorrecte"
#self.Commentaire.setText(texte)
- self.editor.affiche_infos(texte,Qt.red)
+ self.editor.afficheInfos(texte,Qt.red)
return
- listeDecoupee=self.DecoupeListeValeurs(liste)
+ listeDecoupee=self.decoupeListeValeurs(liste)
for vals in listeDecoupee :
self.ajout1Valeur(vals)
- def Sup1Valeur(self):
+ def sup1Valeur(self):
index=self.LBValeurs.currentRow()
if index == None : return
removed_item = self.LBValeurs.takeItem(index)
for i in range(self.nbValeurs):
indexAOter=index*self.nbValeurs + i
indexInterdit.append(indexAOter)
- if self.node.item.wait_tuple()== 1 :
+ if self.node.item.waitTuple()== 1 :
indexInterdit=[index]
i=0
def __init__(self,texte,monOptionnel,parent=None):
QCheckBox.__init__(self,tr(texte),parent)
self.mousePressed=True
- self.texte=texte
self.monOptionnel=monOptionnel
self.setToolTip(tr("clicker: affichage aide, double-click: ajout"))
monAide = ""
except :
monAide = ""
- self.monOptionnel.parentMC.editor.affiche_commentaire(monAide)
+ self.monOptionnel.parentMC.editor.afficheCommentaire(monAide)
class monPBButtonCustom(QWidget,Ui_customPB):
class MonGroupeOptionnel (QWidget,Ui_groupeOptionnel):
"""
"""
- def __init__(self,liste,parentQt,parentMC):
+ def __init__(self,liste,liste_rouge,parentQt,parentMC):
#print "dans init de monWidgetOptionnel ", parentQt, liste,parentMC
QWidget.__init__(self,None)
self.setupUi(self)
self.parentQt=parentQt
self.parentMC=parentMC
if liste != [] :
- self.affiche(liste)
+ self.affiche(liste,liste_rouge)
self.afficheTitre()
elif self.parentQt.parentQt.afficheOptionnelVide != False :
self.afficheTitre()
def afficheTitre(self):
- labeltext,fonte,couleur = self.parentMC.node.item.GetLabelText()
+ labeltext,fonte,couleur = self.parentMC.node.item.getLabelText()
#print (labeltext)
l=tr(labeltext)
li=[]
texte=texte[0:-1]
self.MCLabel.setText(texte)
- def affiche(self,liste):
- #print "dans Optionnel ____ affiche", liste
+ def affiche(self,liste,liste_rouge):
+ #print ("dans Optionnel ____ affiche", liste,liste_rouge)
self.dicoCb={}
liste.reverse()
for mot in liste :
+ if mot in liste_rouge : print ('je dois afficher en rouge' , mot)
if self.parentQt.parentQt.simpleClic == False :
cb = monRBButtonCustom(mot,self)
cb.clicked.connect(cb.ajoutAideMC)
--- /dev/null
+# Copyright (C) 2007-2017 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+# Modules Python
+# Modules Eficas
+
+from __future__ import absolute_import
+try :
+ from builtins import str
+except : pass
+
+from PyQt5.QtWidgets import QButtonGroup, QToolButton
+from PyQt5.QtGui import QIcon, QPixmap
+from Extensions.i18n import tr
+
+
+#----------------------
+class MonLayoutBouton :
+#----------------------
+
+# -------------------------------
+ def __init__(self,appliEficas):
+# -------------------------------
+
+ self.appliEficas = appliEficas
+ self.buttonGroup = QButtonGroup()
+ for nomEtape in self.appliEficas.readercata.cata_ordonne_dico:
+ toolButton = QToolButton(self.appliEficas.toolBarCommande)
+ icon = QIcon()
+ if nomEtape in self.appliEficas.readercata.dicoIcones:
+ fichier = self.appliEficas.readercata.dicoIcones[nomEtape]
+ icon.addPixmap(QPixmap(fichier), QIcon.Normal, QIcon.Off)
+ toolButton.setIcon(icon)
+ else :
+ try : label = nomEtape[0:3]
+ except : label = nomEtape
+ toolButton.setText(label)
+
+ action = self.appliEficas.toolBarCommande.addWidget(toolButton)
+ action.setVisible(True)
+ toolButton.setObjectName(nomEtape)
+ toolButton.setToolTip(tr(nomEtape))
+ self.buttonGroup.addButton(toolButton)
+
+ self.buttonGroup.buttonClicked.connect(self.rbCliqueEtInsere)
+
+ def rbCliqueEtInsere(self,id):
+ self.appliEficas.handleAjoutEtape(id.objectName())
+
+
#if self.motAChercher!=self.LERecherche.text(): self.recherche()
if self.listeTrouvee=={} : return
if self.surLigne > len(self.listeTrouvee) -1 : return
- if self.nodeSurligne!=None : self.nodeSurligne.update_node_texte_in_black()
- #self.listeTrouvee[self.surLigne].update_node_texte_in_blue()
+ if self.nodeSurligne!=None : self.nodeSurligne.updateNodeTexteInBlack()
+ #self.listeTrouvee[self.surLigne].updateNodeTexteInBlue()
#self.nodeSurligne=self.listeTrouvee[self.surLigne]
self.listeTrouvee[self.surLigne].select()
self.listeTrouvee[self.surLigne].affichePanneau()
from desSelectVal import Ui_DSelVal
from Extensions.i18n import tr
-from PyQt5.QtWidgets import QDialog, QFileDialog
+from PyQt5.QtWidgets import QDialog, QFileDialog, QMessageBox
from PyQt5.QtCore import QTimer, Qt
from PyQt5.QtGui import QPalette
self.connecterSignaux()
def connecterSignaux(self) :
- self.Bespace.clicked.connect(self.SelectEsp)
- self.BpointVirgule.clicked.connect(self.SelectPoint)
- self.Bvirgule.clicked.connect(self.SelectVir)
+ self.Bespace.clicked.connect(self.selectEsp)
+ self.BpointVirgule.clicked.connect(self.selectPoint)
+ self.Bvirgule.clicked.connect(self.selectVir)
self.BImportSel.clicked.connect(self.BImportSelPressed)
self.BImportTout.clicked.connect(self.BImportToutPressed)
self.parent.editor.sb.messageChanged.connect(self.messageAChanger)
def connecterSignauxQT4(self) :
- self.connect(self.Bespace,SIGNAL("clicked()"),self.SelectEsp)
- self.connect(self.BpointVirgule,SIGNAL("clicked()"),self.SelectPoint)
- self.connect(self.Bvirgule,SIGNAL("clicked()"),self.SelectVir)
+ self.connect(self.Bespace,SIGNAL("clicked()"),self.selectEsp)
+ self.connect(self.BpointVirgule,SIGNAL("clicked()"),self.selectPoint)
+ self.connect(self.Bvirgule,SIGNAL("clicked()"),self.selectVir)
self.connect(self.BImportSel,SIGNAL("clicked()"),self.BImportSelPressed)
self.connect(self.BImportTout,SIGNAL("clicked()"),self.BImportToutPressed)
self.connect(self.parent.editor.sb,SIGNAL("messageChanged(QString)"),self.messageAChanger)
def readVal(self):
if self.file == "" : return
- f = open(self.file, "r")
- self.texte = f.read()
- f.close()
+ try :
+ f = open(self.file, "r")
+ self.texte = f.read()
+ f.close()
+ except :
+ QMessageBox.warning( self,tr( "Fichier Indisponible"),tr( "Lecture impossible"))
+ self.texte=""
+ return
def initVal(self):
self.TBtext.clear()
self.TBtext.setText(self.texte)
- def SelectEsp(self):
+ def selectEsp(self):
self.separateur=" "
- def SelectVir(self):
+ def selectVir(self):
self.separateur=","
- def SelectPoint(self):
+ def selectPoint(self):
self.separateur=";"
def BImportSelPressed(self):
texte = self.TBtext.textCursor().selectedText()
textTraite=texte.replace(u'\u2029',"\n")
self.textTraite=str(textTraite)
- self.Traitement()
+ self.traitement()
def BImportToutPressed(self):
self.textTraite=self.texte
- self.Traitement()
+ self.traitement()
- def Traitement(self):
+ def traitement(self):
if self.textTraite == "" : return
if self.textTraite[-1]=="\n" : self.textTraite=self.textTraite[0:-1]
self.textTraite=self.textTraite.replace("\n",self.separateur)
if val != '' and val != ' ' and val != self.separateur :
val=str(val)
try :
+ #if 1 :
val2=eval(val,{})
liste.append(val2)
except :
pass
self.parent.ajoutNValeur(liste)
-
def saveFile(self):
#recuperation du nom du fichier
if self.editor != None :
- dir=self.editor.appliEficas.CONFIGURATION.savedir
+ dir=self.editor.appliEficas.maConfiguration.savedir
else:
dir='/tmp'
fn = QFileDialog.getSaveFileName(None,
ulfile = os.path.abspath(six.text_type(fn))
if self.editor != None :
- self.editor.appliEficas.CONFIGURATION.savedir=os.path.split(ulfile)[0]
+ self.editor.appliEficas.maConfiguration.savedir=os.path.split(ulfile)[0]
try:
f = open(fn, 'w')
f.write(str(self.view.toPlainText()))
def __init__(self,node,monSimpDef,nom,objSimp,parentQt,commande):
#print "dans le init de MonWidget4a6RadioButton",self
- self.maListeDeValeur=node.item.get_sd_avant_du_bon_type()
+ self.maListeDeValeur=node.item.getSdAvantDuBonType()
MonWidgetRadioButtonCommun.__init__(self,node,monSimpDef,nom,objSimp,parentQt,commande)
def setMaxI(self):
def __init__(self,node,monSimpDef,nom,objSimp,parentQt,commande):
#print "dans le init de MonWidget4a6RadioButton",self
- self.maListeDeValeur=node.item.get_sd_avant_du_bon_type()
+ self.maListeDeValeur=node.item.getSdAvantDuBonType()
MonWidgetRadioButtonCommun.__init__(self,node,monSimpDef,nom,objSimp,parentQt,commande)
def setMaxI(self):
# Modules Eficas
from Extensions.i18n import tr
-from .feuille import Feuille
-from desWidgetCB import Ui_WidgetCB
-from .politiquesValidation import PolitiqueUnique
-from .qtSaisie import SaisieValeur
+from InterfaceQT4.feuille import Feuille
+from desWidgetCB import Ui_WidgetCB
+from InterfaceQT4.politiquesValidation import PolitiqueUnique
+from InterfaceQT4.qtSaisie import SaisieValeur
from PyQt5.QtWidgets import QComboBox, QCompleter
from PyQt5.QtCore import Qt
-class MonWidgetCBCommun (Ui_WidgetCB,Feuille):
+class MonWidgetCBCommun (Feuille):
def __init__(self,node,monSimpDef,nom,objSimp,parentQt,commande):
Feuille.__init__(self,node,monSimpDef,nom,objSimp,parentQt,commande)
self.politique=PolitiqueUnique(self.node,self.editor)
self.determineChoix()
self.setValeursApresBouton()
- self.CBChoix.currentIndexChanged.connect(self.ChoixSaisi)
+ self.CBChoix.currentIndexChanged.connect(self.choixSaisi)
#self.CBChoix.lineEdit().setText(tr("Select"))
self.parentQt.commandesLayout.insertWidget(-1,self)
self.maCommande.listeAffichageWidget.append(self.CBChoix)
def setValeursApresBouton(self):
- if self.objSimp.get_valeur()==None :
+ if self.objSimp.getValeur()==None :
self.CBChoix.setCurrentIndex(-1)
#self.CBChoix.lineEdit().setStyleSheet(("QLineEdit {" " background:yellow;\n" "font: italic ;\n" " }\n" " "))
self.CBChoix.lineEdit().setText(tr("Select"))
return
- valeur=self.objSimp.get_valeur()
+ valeur=self.objSimp.getValeur()
if not(type(valeur) == str) : valeur=str(valeur)
self.CBChoix.setCurrentIndex(self.CBChoix.findText(valeur))
def determineChoix(self):
listeChoix=[]
+ if self.maListeDeValeur == None : self.maListeDeValeur=[]
for choix in self.maListeDeValeur:
if not(type(choix) == str) : choix=str(choix)
listeChoix.append(choix)
monCompleteur.setCompletionMode(QCompleter.PopupCompletion)
self.CBChoix.setCompleter(monCompleteur)
- def ChoixSaisi(self):
+ def choixSaisi(self):
self.CBChoix.lineEdit().setStyleSheet(("\n"
"QLineEdit {\n"
" font : italic ;\n"
" background: rgb(235,235,235);\n"
" }"))
valeur=str(self.CBChoix.currentText())
- SaisieValeur.LEValeurPressed(self,valeur)
+ SaisieValeur.LEvaleurPressed(self,valeur)
self.reaffiche()
-class MonWidgetCB (MonWidgetCBCommun):
+class MonWidgetCB (Ui_WidgetCB, MonWidgetCBCommun):
def __init__(self,node,monSimpDef,nom,objSimp,parentQt,commande):
self.maListeDeValeur=monSimpDef.into
MonWidgetCBCommun. __init__(self,node,monSimpDef,nom,objSimp,parentQt,commande)
-class MonWidgetCBSD (MonWidgetCBCommun):
+class MonWidgetCBSD (Ui_WidgetCB,MonWidgetCBCommun):
def __init__(self,node,monSimpDef,nom,objSimp,parentQt,commande):
- self.maListeDeValeur=node.item.get_sd_avant_du_bon_type()
+ self.maListeDeValeur=node.item.getSdAvantDuBonType()
MonWidgetCBCommun.__init__(self,node,monSimpDef,nom,objSimp,parentQt,commande)
--- /dev/null
+# -*- coding: utf-8 -*-
+# Copyright (C) 2007-2017 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+# Modules Python
+from __future__ import absolute_import
+try :
+ from builtins import str
+except : pass
+
+import types,os
+
+# Modules Eficas
+from Extensions.i18n import tr
+
+from .feuille import Feuille
+from .politiquesValidation import PolitiqueUnique
+from .qtSaisie import SaisieValeur
+from desWidgetCBIntoSug import Ui_WidgetCBIntoSug
+
+from PyQt5.QtWidgets import QComboBox, QCompleter
+from PyQt5.QtCore import Qt
+
+from monWidgetCB import MonWidgetCBCommun
+from monWidgetIntoSug import GereAjoutDsPossible
+
+
+class MonWidgetCBIntoSug (MonWidgetCBCommun, Ui_WidgetCBIntoSug,GereAjoutDsPossible):
+ def __init__(self,node,monSimpDef,nom,objSimp,parentQt,commande):
+ self.maListeDeValeur=monSimpDef.into
+ if node.item.hasIntoSug() : self.maListeDeValeur=node.item.getListePossibleAvecSug([])
+ if hasattr(node.item,'suggestion') : self.maListeDeValeur+= node.item.suggestion
+ MonWidgetCBCommun. __init__(self,node,monSimpDef,nom,objSimp,parentQt,commande)
+ self.lineEditVal.returnPressed.connect(self.LEValeurAjouteDsPossible)
+
+ def ajouteValeurPossible(self,valeur):
+ self.CBChoix.addItem(valeur)
+ # on ne sait pas si on a deja ajouté une valeur
+ try : self.node.item.suggestion.append(valeur)
+ except : self.node.item.suggestion=(valeur,)
+ self.lineEditVal.setText('')
+ self.CBChoix.setCurrentIndex(self.CBChoix.findText(valeur));
+
+
self.politique=PolitiqueUnique(self.node,self.editor)
self.determineChoix()
self.setValeursApresBouton()
- self.CBChoix.currentIndexChanged.connect(self.ChoixSaisi)
+ self.CBChoix.currentIndexChanged.connect(self.choixSaisi)
self.parentQt.commandesLayout.insertWidget(-1,self)
self.maCommande.listeAffichageWidget.append(self.CBChoix)
- #print self.objSimp.isoblig()
+ #print self.objSimp.isOblig()
def setValeursApresBouton(self):
- if self.objSimp.get_valeur()==None :
+ if self.objSimp.getValeur()==None :
self.CBChoix.setCurrentIndex(-1)
return
- valeur=self.objSimp.get_valeur()
+ valeur=self.objSimp.getValeur()
if not(type(valeur) == str) : valeur=str(valeur)
self.CBChoix.setCurrentIndex(self.CBChoix.findText(valeur))
def determineChoix(self):
- self.CBChoix.currentIndexChanged.connect(self.ChoixSaisi)
+ self.CBChoix.currentIndexChanged.connect(self.choixSaisi)
for choix in self.monSimpDef.into:
if not(type(choix) == str) : choix=str(choix)
- self.CBChoix.currentIndexChanged.connect(self.ChoixSaisi)
+ self.CBChoix.currentIndexChanged.connect(self.choixSaisi)
self.CBChoix.addItem(choix)
self.CBChoix.setEditable(True)
monCompleteur=QCompleter(listeChoix,self)
monCompleteur.setCompletionMode(QCompleter.PopupCompletion)
self.CBChoix.setCompleter(monCompleteur)
- def ChoixSaisi(self):
+ def choixSaisi(self):
valeur=str(self.CBChoix.currentText())
- SaisieValeur.LEValeurPressed(self,valeur)
+ SaisieValeur.LEvaleurPressed(self,valeur)
self.reaffiche()
Groupe.__init__(self,node,editor,None,etape.definition,etape,1,self)
editor.inhibeSplitter=0
- self.frameAffichage.setMinimumHeight(20)
- if node.item.get_fr() != "" : self.labelDoc.setText(node.item.get_fr())
- else :
- self.labelDoc.close()
- self.frameAffichage.resize(self.frameAffichage.width(),50)
+ resize=0
+ if node.item.getFr() != "" :
+ self.labelDoc.setText(node.item.getFr())
+ resize=1
+ else : self.labelDoc.close()
- #if (etape.get_type_produit()==None): self.LENom.close()
- #test,mess = self.node.item.nomme_sd('ee')
if not(hasattr(etape.definition,'sd_prod')) or (etape.definition.sd_prod==None): self.LENom.close()
elif (hasattr(etape.definition,'sd_prod') and type(etape.definition.sd_prod)== types.FunctionType):self.LENom.close()
- elif (hasattr(etape, 'sdnom')) and etape.sdnom != "sansnom" and etape.sdnom != None: self.LENom.setText(etape.sdnom)
- else : self.LENom.setText("")
+ elif (hasattr(etape, 'sdnom')) and etape.sdnom != "sansnom" and etape.sdnom != None:
+ self.LENom.setText(etape.sdnom)
+ resize=resize*1
+ else :
+ self.LENom.setText("")
+ resize=resize*1
+ if resize :
+ nouvelleSize=self.frameAffichage.height()+60
+ self.frameAffichage.setMinimumHeight(nouvelleSize)
+ self.frameAffichage.resize(self.frameAffichage.width(),nouvelleSize)
+
maPolice= QFont("Times", 10,)
self.labelNomCommande.setText(tr(self.obj.nom))
- if self.editor.closeAutreCommande==True : self.closeAutreCommande()
+ if self.editor.closeAutreCommande == True : self.closeAutreCommande()
else :
try :
self.bCatalogue.clicked.connect(self.afficheCatalogue)
self.bApres.clicked.connect(self.afficheApres)
except :
pass
- self.LENom.returnPressed.connect(self.nomChange)
+
+ if hasattr(self,'LENom'): self.LENom.returnPressed.connect(self.nomChange)
if self.editor.code in ['Adao','ADAO'] and self.editor.closeFrameRechercheCommande==True :
self.frameAffichage.close()
if self.editor.code in ['CARMELCND',] : self.closeAutreCommande()
self.racine=self.node.tree.racine
- if self.node.item.GetIconName() == "ast-red-square" : self.LENom.setDisabled(True)
+ if self.node.item.getIconName() == "ast-red-square" : self.LENom.setDisabled(True)
self.setAcceptDrops(True)
self.etablitOrdre()
self.editor.ajoutOptionnel()
self.editor.inhibeSplitter=0
self.afficheOptionnel()
+ spacerItem = QSpacerItem(21, 20, QSizePolicy.MinimumExpanding, QSizePolicy.MinimumExpanding)
+ self.commandesLayout.addItem(spacerItem)
+
#self.editor.restoreSplitterSizes()
#print "fin init de widget Commande"
pass
def nomChange(self):
+ print (1)
nom = str(self.LENom.text())
nom = nom.strip()
if nom == '' : return # si pas de nom, on ressort sans rien faire
- test,mess = self.node.item.nomme_sd(nom)
- self.editor.affiche_commentaire(mess)
+ print (2)
+ test,mess = self.node.item.nommeSd(nom)
+ print (test,mess)
+ self.editor.afficheCommentaire(mess)
+ print (3)
#Notation scientifique
if test :
from .politiquesValidation import Validation
validation=Validation(self.node,self.editor)
- validation.AjoutDsDictReelEtape()
+ validation.ajoutDsDictReelEtape()
def afficheOptionnel(self):
# N a pas de parentQt. doit donc etre redefini
- liste=self.ajouteMCOptionnelDesBlocs()
+ liste,liste_rouge=self.ajouteMCOptionnelDesBlocs()
#print "dans afficheOptionnel", self.monOptionnel
# dans le cas ou l insertion n a pas eu leiu (souci d ordre par exemple)
#if self.monOptionnel == None : return
self.monOptionnel.parentCommande=self
self.monOptionnel.titre(self.obj.nom)
- self.monGroupe=self.monOptionnel.afficheOptionnel(liste,self)
+ self.monGroupe=self.monOptionnel.afficheOptionnel(liste,liste_rouge,self)
def focusInEvent(self,event):
def setValide(self):
if not(hasattr (self,'RBValide')) : return
icon = QIcon()
- if self.node.item.object.isvalid() :
- icon=QIcon(self.repIcon+"/ast-green-ball.png")
- else :
- icon=QIcon(self.repIcon+"/ast-red-ball.png")
- if self.node.item.GetIconName() == "ast-yellow-square" :
- icon=QIcon(self.repIcon+"/ast-yel-ball.png")
+ if self.node.item.object.isValid() : icon=QIcon(self.repIcon+"/ast-green-ball.png")
+ else : icon=QIcon(self.repIcon+"/ast-red-ball.png")
+ nomIcone = self.node.item.getIconName()
+ if nomIcone == "ast-yellow-square" : icon=QIcon(self.repIcon+"/ast-yel-ball.png")
+ if nomIcone == "ast-red-square" : self.LENom.setDisabled(True)
+
self.LENom.setDisabled(False)
- if self.node.item.GetIconName() == "ast-red-square" : self.LENom.setDisabled(True)
self.RBValide.setIcon(icon)
else : self.node.tree.racine.select()
def remplitTexte(self):
- texte=self.node.item.get_valeur()
+ texte=self.node.item.getValeur()
self.commentaireTE.setText(texte)
if self.editor.code == "CARMELCND" and texte[0:16]=="Cree - fichier :" :
self.commentaireTE.setReadOnly(True)
def TexteCommentaireEntre(self):
texte=str(self.commentaireTE.toPlainText())
- self.editor.init_modif()
- self.node.item.set_valeur(texte)
- self.node.update_node_texte()
+ self.editor.initModif()
+ self.node.item.setValeur(texte)
+ self.node.updateNodeTexte()
"""
def __init__(self,editor, name = None,fl = 0):
self.editor=editor
- self.editor.affiche_infos("")
+ self.editor.afficheInfos("")
QDialog.__init__(self,editor)
self.setupUi(self)
self.connecterSignaux()
return
param= self.dictListe[item.text()]
self.editor.nodeEnCours.lineEditVal.setText(param)
- self.editor.nodeEnCours.LEValeurPressed()
+ self.editor.nodeEnCours.LEvaleurPressed()
- def CreeParametre(self):
+ def creeParametre(self):
nom=str(self.lineEditNom.text())
val=str(self.lineEditVal.text())
if val == "" or None : return
else :
itemAvant=self.editor.tree.selectedItems()[0]
param=itemAvant.addParameters(True)
- param.item.set_nom(nom)
+ param.item.setNom(nom)
#PN self.val permet d entrer du texte
- param.item.set_valeur(self.val)
- param.update_node_texte()
- param.update_node_valid()
+ param.item.setValeur(self.val)
+ param.updateNodeTexte()
+ param.updateNodeValid()
self.LBParam.addItem((repr(param.item.object)))
self.dictListe[repr(param.item.object)] = param.item.object.nom
self.lineEditVal.setText("")
exec("from math import *", contexte)
jdc=self.editor.jdc
if jdc == None :
- self.editor.affiche_infos(tr(u"La Creation de parametre n est possible que dans un jeu de donnees"),Qt.red)
+ self.editor.afficheInfos(tr(u"La Creation de parametre n est possible que dans un jeu de donnees"),Qt.red)
return
for p in jdc.params :
monTexte="monParam='"+valString+"'"
self.val="'"+valString+"'"
except :
- self.editor.affiche_infos(tr("Valeur incorrecte"),Qt.red)
- if self.lineEditNom.text()!="" and self.dejaExistant==False : self.CreeParametre()
+ self.editor.afficheInfos(tr("Valeur incorrecte"),Qt.red)
+ if self.lineEditNom.text()!="" and self.dejaExistant==False : self.creeParametre()
def lineEditNomReturnPressed(self):
if not pattern_name.match(nom) :
self.lineEditNom.setText("")
commentaire=nom + tr(" n est pas un identifiant correct\n ")
- self.editor.affiche_infos(commentaire,Qt.red)
+ self.editor.afficheInfos(commentaire,Qt.red)
for p in self.editor.jdc.params :
if p.nom==nom :
commentaire=nom + tr(" existe deja\n ")
- self.editor.affiche_infos(commentaire,Qt.red)
+ self.editor.afficheInfos(commentaire,Qt.red)
return
- if self.lineEditVal.text()!="" : self.CreeParametre()
+ if self.lineEditVal.text()!="" : self.creeParametre()
self.lineEditVal.setFocus(Qt.OtherFocusReason)
def __init__(self,node,editor,parentQt,definition, obj, niveau,commande,insertIn=-1):
#print "fact : ",node.item.nom
Groupe.__init__(self,node,editor,parentQt, definition,obj,niveau,commande)
- labeltext,fonte,couleur = self.node.item.GetLabelText()
+ labeltext,fonte,couleur = self.node.item.getLabelText()
self.GroupBox.setText(tr(labeltext))
self.GroupBox.setTextInteractionFlags(Qt.TextSelectableByMouse)
self.parentQt.commandesLayout.insertWidget(insertIn,self)
self.doitAfficherOptionnel=False
def enterEvent(self,event):
- #print "enterEvent ", self.node.item.GetLabelText()[0]
+ #print "enterEvent ", self.node.item.getLabelText()[0]
self.doitAfficherOptionnel=True
QWidget.enterEvent(self,event)
QTimer.singleShot(500, self.delayAffiche)
def leaveEvent(self,event):
- #print "leaveEvent", self.node.item.GetLabelText()[0]
+ #print "leaveEvent", self.node.item.getLabelText()[0]
self.doitAfficherOptionnel=False
QWidget.leaveEvent(self,event)
def __init__(self,node,editor,parentQt,definition, obj, niveau,commande,insertIn=-1):
#print "fact plie : ",node.item.nom
Groupe.__init__(self,node,editor,parentQt, definition,obj,niveau,commande)
- self.groupBox.setText(self.node.item.GetLabelText()[0])
+ self.groupBox.setText(self.node.item.getLabelText()[0])
self.parentQt.commandesLayout.insertWidget(insertIn,self)
def traiteClicSurLabel(self,texte):
self.bAvant.clicked.connect(self.afficheAvant)
self.bApres.clicked.connect(self.afficheApres)
self.LENom.returnPressed.connect(self.nomChange)
- self.LENomFormule.returnPressed.connect(self.NomFormuleSaisi)
+ self.LENomFormule.returnPressed.connect(self.nomFormuleSaisi)
self.LENomsArgs.returnPressed.connect(self.argsSaisis)
self.LECorpsFormule.returnPressed.connect(self.FormuleSaisie)
def setValeurs(self):
- self.LENomFormule.setText(self.node.item.get_nom())
- self.LECorpsFormule.setText(self.node.item.get_corps())
+ self.LENomFormule.setText(self.node.item.getNom())
+ self.LECorpsFormule.setText(self.node.item.getCorps())
texte_args=""
- if self.node.item.get_args() != None :
- for i in self.node.item.get_args() :
+ if self.node.item.getArgs() != None :
+ for i in self.node.item.getArgs() :
if texte_args != "" : texte_args = texte_args +","
texte_args=texte_args + i
self.LENomsArgs.setText(texte_args)
def nomChange(self):
nom = str(self.LENom.text())
self.LENomFormule.setText(nom)
- self.NomFormuleSaisi()
+ self.nomFormuleSaisi()
def afficheCatalogue(self):
def setValide(self):
if not(hasattr (self,'RBValide')) : return
icon = QIcon()
- if self.node.item.object.isvalid() :
+ if self.node.item.object.isValid() :
icon=QIcon(self.repIcon+"/ast-green-ball.png")
else :
icon=QIcon(self.repIcon+"/ast-red-ball.png")
- if self.node.item.GetIconName() == "ast-yellow-square" :
+ if self.node.item.getIconName() == "ast-yellow-square" :
icon=QIcon(self.repIcon+"/ast-yel-ball.png")
self.RBValide.setIcon(icon)
- def NomFormuleSaisi(self):
+ def nomFormuleSaisi(self):
nomFormule = str(self.LENomFormule.text())
if nomFormule == '' : return
self.LENom.setText(nomFormule)
- test,erreur = self.node.item.verif_nom(nomFormule)
+ test,erreur = self.node.item.verifNom(nomFormule)
if test :
commentaire=nomFormule+tr(" est un nom valide pour une FORMULE")
- self.editor.affiche_infos(commentaire)
+ self.editor.afficheInfos(commentaire)
else :
commentaire=nomFormule+tr(" n'est pas un nom valide pour une FORMULE")
- self.editor.affiche_infos(commentaire,Qt.red)
+ self.editor.afficheInfos(commentaire,Qt.red)
return
if str(self.LENomsArgs.text()) != "" and str(self.LECorpsFormule.text())!= "" : self.BOkPressedFormule()
self.LENomsArgs.setFocus(7)
def argsSaisis(self):
arguments = str(self.LENomsArgs.text())
if arguments == '' : return
- test,erreur = self.node.item.verif_arguments(arguments)
+ test,erreur = self.node.item.verifArguments(arguments)
if test:
commentaire=tr("Argument(s) valide(s) pour une FORMULE")
- self.editor.affiche_infos(commentaire)
+ self.editor.afficheInfos(commentaire)
else:
commentaire=tr("Argument(s) invalide(s) pour une FORMULE")
- self.editor.affiche_infos(commentaire,Qt.red)
+ self.editor.afficheInfos(commentaire,Qt.red)
if str(self.LECorpsFormule.text()) != "" and str(self.LENomFormule.text())!= "" : self.BOkPressedFormule()
self.LECorpsFormule.setFocus(7)
arguments = str(self.LENomsArgs.text())
expression = str(self.LECorpsFormule.text())
if expression == '' : return
- test,erreur = self.node.item.verif_formule_python((nomFormule,"REEL",arguments,expression))
+ test,erreur = self.node.item.verifFormule_python((nomFormule,"REEL",arguments,expression))
if test:
commentaire=tr("Corps de FORMULE valide")
- self.editor.affiche_infos(commentaire)
+ self.editor.afficheInfos(commentaire)
else:
commentaire=tr("Corps de FORMULE invalide")
- self.editor.affiche_infos(commentaire,Qt.red)
+ self.editor.afficheInfos(commentaire,Qt.red)
if str(self.LENomsArgs.text()) != "" and str(self.LENomFormule.text())!= "" : self.BOkPressedFormule()
def BOkPressedFormule(self):
#print dir(self)
- #if self.parent.modified == 'n' : self.parent.init_modif()
+ #if self.parent.modified == 'n' : self.parent.initModif()
nomFormule = str(self.LENomFormule.text())
- test,erreur = self.node.item.verif_nom(nomFormule)
+ test,erreur = self.node.item.verifNom(nomFormule)
if not test :
- self.editor.affiche_infos(erreur,Qt.red)
+ self.editor.afficheInfos(erreur,Qt.red)
return
arguments = str(self.LENomsArgs.text())
- test,erreur = self.node.item.verif_arguments(arguments)
+ test,erreur = self.node.item.verifArguments(arguments)
if not test :
- self.editor.affiche_infos(erreur,Qt.red)
+ self.editor.afficheInfos(erreur,Qt.red)
return
expression = str(self.LECorpsFormule.text())
- test,erreur = self.node.item.verif_formule_python((nomFormule,"REEL",arguments,expression))
+ test,erreur = self.node.item.verifFormule_python((nomFormule,"REEL",arguments,expression))
if not test :
- self.editor.affiche_infos(erreur,Qt.red)
+ self.editor.afficheInfos(erreur,Qt.red)
return
test=self.node.item.object.update_formule_python(formule=(nomFormule,"REEL",arguments,expression))
- test,erreur = self.node.item.save_formule(nomFormule,"REEL",arguments,expression)
+ test,erreur = self.node.item.saveFormule(nomFormule,"REEL",arguments,expression)
if test :
- #self.node.update_texte()
- #self.node.update_label()
- #self.node.update_node()
self.node.onValid()
self.node.update_valid()
commentaire = "Formule saisie"
- self.editor.affiche_infos(commentaire)
+ self.editor.afficheInfos(commentaire)
else:
commentaire ="Formule incorrecte : " + erreur
- self.editor.affiche_infos(commentaire,Qt.red)
- self.editor.init_modif()
+ self.editor.afficheInfos(commentaire,Qt.red)
+ self.editor.initModif()
def __init__(self,node,monSimpDef,nom,objSimp,parentQt,commande):
QWidget.__init__(self,None)
self.setupUi(self)
- valeur=node.item.get_valeur()
+ valeur=node.item.getValeur()
self.lineEditVal.setText(str(valeur))
self.lineEditVal.setReadOnly(True)
parentQt.commandesLayout.insertWidget(-1,self)
from desWidgetIntoSug import Ui_WidgetIntoSug
from monWidgetPlusieursInto import MonWidgetPlusieursInto
-class MonWidgetIntoSug (Ui_WidgetIntoSug, MonWidgetPlusieursInto):
+class GereAjoutDsPossible:
+ def LEValeurAjouteDsPossible(self):
+ text=str(self.lineEditVal.text())
+ if text == "" : return
+ # il faudrait essauer d en obtenir un reel, un tuple ou ...
+ # si cela est utilise pour autre chose que Telemac
+ # tout devrait etre fait ici
+ if not isinstance(text,str) :
+ self.lineEditVal.setText("")
+ return
+ if self.node.item.hasIntoSug() :
+ self.maListeDeValeur=list(self.node.item.getListePossibleAvecSug([]))
+ self.maListeDeValeur.insert(0,text)
+ else :
+ try :
+ self.monSimpDef.intoSug.insert(0,text)
+ except :
+ self.monSimpDef.intoSug=list(self.monSimpDef.intoSug)
+ self.monSimpDef.intoSug.insert(0,text)
+ # selon si on est une liste ou un combo
+ try : self.ajouteValeurPossible(text)
+ except : self.setValeurs()
+
+class MonWidgetIntoSug (Ui_WidgetIntoSug, MonWidgetPlusieursInto,GereAjoutDsPossible):
# Attention Attention
# cette wdget ne fonctionne actuellement que pour Telemac
# on attend du texte . on n essaye pas de transformer
MonWidgetPlusieursInto.__init__(self,node,monSimpDef,nom,objSimp,parentQt,commande)
self.lineEditVal.returnPressed.connect(self.LEValeurAjouteDsPossible)
- def LEValeurAjouteDsPossible(self):
- text=str(self.lineEditVal.text())
- if text == "" : return
- # il faudrait essauer d en obtenir un reel, un tuple ou ...
- # si cela est utilise pour autre chose que Telemac
- if not isinstance(text,str) :
- self.lineEditVal.setText("")
- print ('jkjkl')
- return
- self.monSimpDef.intoSug.insert(0,text)
- self.setValeurs()
self.nomVariables={}
self.creeColonnes()
self.connecterSignaux()
- if self.node.item.get_valeur()== None: self.initialSsValeur()
+ if self.node.item.getValeur()== None: self.initialSsValeur()
else :
try : self.initialValeur()
except : self.initialSsValeur()
def afficheEntete(self):
self.objSimp.changeEnteteMatrice()
self.TBMatrice.clear()
- if self.node.item.get_valeur()== None: self.initialSsValeur()
+ if self.node.item.getValeur()== None: self.initialSsValeur()
else :
try : self.initialValeur()
except : self.initialSsValeur()
self.node.item.object.parent.state='changed'
self.setValide()
self.parentQt.setValide()
- self.node.item.jdc.isvalid()
+ self.node.item.jdc.isValid()
def itemChanged(self):
else :
ok=False
if ok == False :
- self.editor.affiche_infos(tr("Entrer un float SVP"),Qt.red)
+ self.editor.afficheInfos(tr("Entrer un float SVP"),Qt.red)
monItem.setText("")
return
if self.monType.valSup != None :
if val > self.monType.valSup :
- self.editor.affiche_infos(tr("Entrer un float inferieur a ") + repr(self.monType.valSup),Qt.red)
+ self.editor.afficheInfos(tr("Entrer un float inferieur a ") + repr(self.monType.valSup),Qt.red)
monItem.setText("")
return
if self.monType.valMin != None :
if val < self.monType.valMin :
- self.editor.affiche_infos(tr("Entrer un float superieur a ") + repr(self.monType.valMin),Qt.red)
+ self.editor.afficheInfos(tr("Entrer un float superieur a ") + repr(self.monType.valMin),Qt.red)
monItem.setText("")
return
- self.editor.affiche_infos("")
+ self.editor.afficheInfos("")
if self.monType.structure != None: MonWidgetMatrice.__dict__[self.monType.structure](*(self,))
self.acceptVal()
self.nbCols=self.monType.nbCols
- def NbDeVariables(self):
+ def nbDeVariables(self):
jdc=self.node.item.object.jdc
etape=self.node.item.object.etape
self.listeVariables=jdc.get_variables(etape)
self.nbLigs=len(self.listeVariables)
self.nbCols=len(self.listeVariables)
- def NbDeDistributions(self):
+ def nNbDeDistributions(self):
jdc=self.node.item.object.jdc
etape=self.node.item.object.etape
self.listeVariables=jdc.get_distributions(etape)
self.TBMatrice.setHorizontalHeaderLabels(header)
def initialValeur(self):
- liste=self.node.item.get_valeur()
+ liste=self.node.item.getValeur()
dejaAffiche=0
if (len(liste)) != self.nbLigs +1 :
QMessageBox.critical( self,tr( "Mauvaise dimension de matrice"),tr( "le nombre de ligne n est pas egal a ") + str(self.nbLigs))
listeCol.append(val)
liste.append(listeCol)
# on ajoute l ordre des variables aux valeurs
- self.node.item.set_valeur(liste)
+ self.node.item.setValeur(liste)
--- /dev/null
+# Copyright (C) 2007-2017 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+# Modules Python
+# Modules Eficas
+
+from __future__ import absolute_import
+try :
+ from builtins import str
+except : pass
+
+import types
+
+from desWidgetNiveauFact import Ui_WidgetNiveauFact
+from InterfaceQT4.groupe import Groupe
+#from .gereIcones import FacultatifOuOptionnel
+
+from PyQt5.QtWidgets import QWidget
+#from PyQt5.QtWidgets import QApplication, QWidget, QSpacerItem, QSizePolicy
+#from PyQt5.QtGui import QFont, QIcon
+#from PyQt5.QtCore import QTimer
+#from PyQt5.QtCore import Qt
+
+
+
+from Extensions.i18n import tr
+import Accas
+import os
+
+
+# Import des panels
+
+class MonWidgetNiveauFact(Ui_WidgetNiveauFact,Groupe):
+ """
+ """
+ def __init__(self,node,editor,definition,obj):
+ #QWidget.__init__(self,editor)
+ #self.setupUi(self)
+ self.listeAffichageWidget=[]
+ Groupe.__init__(self,node,editor,None,definition,obj,1,self)
+
+ def reaffiche(self,nodeAVoir=None):
+ print ('PNPNPN a programmer')
+#
+# self.listeAffichageWidget=[]
+# self.inhibe=0
+# self.ensure=0
+# editor.inhibeSplitter=1
+# editor.inhibeSplitter=0
+#
+# self.frameAffichage.setMinimumHeight(20)
+# if node.item.getFr() != "" : self.labelDoc.setText(node.item.getFr())
+# else :
+# self.labelDoc.close()
+# self.frameAffichage.resize(self.frameAffichage.width(),50)
+#
+# #if (etape.getType_produit()==None): self.LENom.close()
+# #test,mess = self.node.item.nommeSd('ee')
+# if not(hasattr(etape.definition,'sd_prod')) or (etape.definition.sd_prod==None): self.LENom.close()
+# elif (hasattr(etape.definition,'sd_prod') and type(etape.definition.sd_prod)== types.FunctionType):self.LENom.close()
+# elif (hasattr(etape, 'sdnom')) and etape.sdnom != "sansnom" and etape.sdnom != None: self.LENom.setText(etape.sdnom)
+# else : self.LENom.setText("")
+#
+#
+# maPolice= QFont("Times", 10,)
+# self.setFont(maPolice)
+# self.labelNomCommande.setText(tr(self.obj.nom))
+#
+#
+# if self.editor.closeAutreCommande == True : self.closeAutreCommande()
+# else :
+# try :
+# self.bCatalogue.clicked.connect(self.afficheCatalogue)
+# self.bAvant.clicked.connect(self.afficheAvant)
+# self.bApres.clicked.connect(self.afficheApres)
+# except :
+# pass
+# self.LENom.returnPressed.connect(self.nomChange)
+#
+# if self.editor.code in ['Adao','ADAO'] and self.editor.closeFrameRechercheCommande==True :
+# self.frameAffichage.close()
+#
+# if self.editor.code in ['CARMELCND',] : self.closeAutreCommande()
+# self.racine=self.node.tree.racine
+# if self.node.item.getIconName() == "ast-red-square" : self.LENom.setDisabled(True)
+#
+# self.setAcceptDrops(True)
+# self.etablitOrdre()
+#
+# if self.editor.code == "CARMELCND" :
+# self.RBPoubelle.close() # JDC Fige
+# return # Pas de MC Optionnels pour Carmel
+#
+# from .monWidgetOptionnel import MonWidgetOptionnel
+# if self.editor.widgetOptionnel!= None :
+# self.monOptionnel=self.editor.widgetOptionnel
+# else :
+# self.editor.inhibeSplitter=1
+# self.monOptionnel=MonWidgetOptionnel(self.editor)
+# self.editor.widgetOptionnel=self.monOptionnel
+# self.editor.splitter.addWidget(self.monOptionnel)
+# self.editor.ajoutOptionnel()
+# self.editor.inhibeSplitter=0
+# self.afficheOptionnel()
+# #self.editor.restoreSplitterSizes()
+#
+# #print "fin init de widget Commande"
+#
+#
+# def closeAutreCommande(self):
+# self.bCatalogue.close()
+# self.bAvant.close()
+# self.bApres.close()
+#
+# def donnePremier(self):
+# #print "dans donnePremier"
+# QApplication.processEvents()
+# if self.listeAffichageWidget != [] :
+# self.listeAffichageWidget[0].setFocus(7)
+# QApplication.processEvents()
+# #print self.focusWidget()
+#
+#
+# def focusNextPrevChild(self, next):
+# # on s assure que ce n est pas un chgt de fenetre
+# #print "je passe dans focusNextPrevChild"
+# if self.editor.fenetreCentraleAffichee != self : return True
+# f=self.focusWidget()
+# if f not in self.listeAffichageWidget :
+# i=0
+# while not hasattr (f,'AAfficher') :
+# if f==None :i=-1; break
+# f=f.parentWidget()
+# if hasattr(f,'AAfficher') : f=f.AAfficher
+# if i != -1 : i=self.listeAffichageWidget.index(f)
+# else :i=self.listeAffichageWidget.index(f)
+# if (i==len(self.listeAffichageWidget) -1) and next and not self.inhibe:
+# try :
+# self.listeAffichageWidget[1].setFocus(7)
+# w=self.focusWidget()
+# self.inhibe=1
+# w.focusPreviousChild()
+# self.inhibe=0
+# return True
+# except :
+# pass
+# #print self.listeAffichageWidget
+# #print "souci ds focusNextPrevChild"
+# if i==0 and next==False and not self.inhibe:
+# if hasattr(self.editor.fenetreCentraleAffichee,'scrollArea'):
+# self.editor.fenetreCentraleAffichee.scrollArea.ensureWidgetVisible(self.listeAffichageWidget[-1])
+# self.listeAffichageWidget[-2].setFocus(7)
+# self.inhibe=1
+# w=self.focusWidget()
+# w.focusNextChild()
+# self.inhibe=0
+# return True
+# if i==0 and next==True and not self.inhibe:
+# self.listeAffichageWidget[0].setFocus(7)
+# self.inhibe=1
+# w=self.focusWidget()
+# w.focusNextChild()
+# self.inhibe=0
+# return True
+# if i>0 and next==False and not self.inhibe:
+# if isinstance(self.listeAffichageWidget[i-1],QRadioButton):
+# self.listeAffichageWidget[i-1].setFocus(7)
+# return True
+# return QWidget.focusNextPrevChild(self, next)
+#
+# def etablitOrdre(self):
+# i=0
+# while(i +1 < len(self.listeAffichageWidget)):
+# self.setTabOrder(self.listeAffichageWidget[i],self.listeAffichageWidget[i+1])
+# i=i+1
+# # si on boucle on perd l'ordre
+#
+# def afficheNieme(self,n):
+# #print ('ds afficheNieme')
+# self.listeAffichageWidget[n].setFocus(7)
+#
+# def afficheSuivant(self,f):
+# #print ('ds afficheSuivant')
+# try :
+# i=self.listeAffichageWidget.index(f)
+# next=i+1
+# except :
+# next=1
+# if (next==len(self.listeAffichageWidget) ): next =0
+# #self.f=next
+# #QTimer.singleShot(1, self.rendVisible)
+# try :
+# self.listeAffichageWidget[next].setFocus(7)
+# except :
+# pass
+#
+#
+# def afficheOptionnel(self):
+# # N a pas de parentQt. doit donc etre redefini
+# liste,liste_rouge=self.ajouteMCOptionnelDesBlocs()
+# #print "dans afficheOptionnel", self.monOptionnel
+# # dans le cas ou l insertion n a pas eu leiu (souci d ordre par exemple)
+# #if self.monOptionnel == None : return
+# self.monOptionnel.parentCommande=self
+# self.monOptionnel.titre(self.obj.nom)
+# self.monGroupe=self.monOptionnel.afficheOptionnel(liste,liste_rouge,self)
+#
+#
+# def focusInEvent(self,event):
+# #print "je mets a jour dans focusInEvent de monWidget Commande "
+# if self.editor.code == "CARMELCND" : return #Pas de MC Optionnels pour Carmel
+# self.afficheOptionnel()
+#
+#
+# def reaffiche(self,nodeAVoir=None):
+# # Attention delicat. les appels de fonctions ne semblent pas pouvoir etre supprimes!
+# self.avantH=self.editor.fenetreCentraleAffichee.scrollAreaCommandes.horizontalScrollBar().sliderPosition()
+# self.avantV=self.editor.fenetreCentraleAffichee.scrollAreaCommandes.verticalScrollBar().sliderPosition()
+# self.inhibeExpand=True
+# self.node.affichePanneau()
+# #QTimer.singleShot(1, self.recentre)
+# if nodeAVoir != None and nodeAVoir!=0:
+# self.f=nodeAVoir.fenetre
+# if self.f==None :
+# newNode=nodeAVoir.treeParent.chercheNoeudCorrespondant(nodeAVoir.item.object)
+# self.f = newNode.fenetre
+# if self.f != None and self.f.isVisible() : self.inhibeExpand=False; return
+# if self.f != None : self.rendVisible()
+# else : self.recentre()
+# else : self.recentre()
+# self.inhibeExpand=False
+#
+# def reafficheSeulement(self,nodeAReafficher,index):
+# #print ('ds reafficheSeulement', nodeAReafficher)
+# parentNodeAReafficher=nodeAReafficher.parentQt
+# index=parentNodeAReafficher.commandesLayout.indexOf(nodeAReafficher)
+# oldFenetre=nodeAReafficher.node.fenetre
+# newWidget=nodeAReafficher.node.getPanelGroupe(parentNodeAReafficher,self,index)
+# nodeAReafficher.node.fenetre=newWidget
+# oldFenetre.setParent(None)
+# oldFenetre.close()
+# oldFenetre.deleteLater()
+# #print ("fin pour " , self.node.item.nom)
+#
+#
+# def recentre(self):
+# QApplication.processEvents()
+# s=self.editor.fenetreCentraleAffichee.scrollAreaCommandes
+# s.horizontalScrollBar().setSliderPosition(self.avantH)
+# s.verticalScrollBar().setSliderPosition(self.avantV)
+#
+# def rendVisibleNoeud(self,node):
+# self.f=node.fenetre
+# #print "dans rendVisibleNoeud",self.f
+# QTimer.singleShot(1, self.rendVisible)
+#
+# def rendVisible(self):
+# #print "dans rendVisible",self.f
+# QApplication.processEvents()
+# self.f.setFocus(7)
+# self.editor.fenetreCentraleAffichee.scrollAreaCommandes.ensureWidgetVisible(self.f)
+#
+# def afficheCatalogue(self):
+# if self.editor.widgetOptionnel != None : self.monOptionnel.hide()
+# self.racine.affichePanneau()
+# if self.node : self.node.select()
+# else : self.racine.select()
+#
+# def afficheApres(self):
+# self.node.selectApres()
+#
+# def afficheAvant(self):
+# self.node.selectAvant()
+#
+# def setValide(self):
+# if not(hasattr (self,'RBValide')) : return
+# icon = QIcon()
+# if self.node.item.object.isValid() :
+# icon=QIcon(self.repIcon+"/ast-green-ball.png")
+# else :
+# icon=QIcon(self.repIcon+"/ast-red-ball.png")
+# if self.node.item.getIconName() == "ast-yellow-square" :
+# icon=QIcon(self.repIcon+"/ast-yel-ball.png")
+# self.LENom.setDisabled(False)
+# if self.node.item.getIconName() == "ast-red-square" : self.LENom.setDisabled(True)
+# self.RBValide.setIcon(icon)
+#
self.dicoMCWidgetOptionnel={}
self.parentQt=parentQt
- def afficheOptionnel(self,liste,MC):
+ def afficheOptionnel(self,liste,liste_rouge,MC):
#print ('afficheOptionnel MonWidgetOptionnel', self,liste,MC)
- #import traceback
- #traceback.print_stack()
self.vireLesAutres(MC)
+
if MC.node.item.nom in self.dicoMCWidgetOptionnel :
self.dicoMCWidgetOptionnel[MC.node.item.nom].close()
self.dicoMCWidgetOptionnel[MC.node.item.nom].setParent(None)
self.dicoMCWidgetOptionnel[MC.node.item.nom].deleteLater()
- groupe = MonGroupeOptionnel(liste,self,MC)
+ groupe = MonGroupeOptionnel(liste,liste_rouge,self,MC)
self.groupesOptionnelsLayout.insertWidget(0,groupe)
self.dicoMCWidgetOptionnel[MC.node.item.nom]=groupe
return groupe
def vireLesAutres(self,MC):
#print( "je passe dans vireLesAutres")
- genea =MC.obj.get_genealogie()
+ genea =MC.obj.getGenealogie()
#print (genea)
for k in list(self.dicoMCWidgetOptionnel.keys()):
#if k not in genea : print ( k)
if self.parentCommande.node.editor.code in ['Adao','ADAO'] and self.parentCommande.node.editor.closeFrameRechercheCommande==True :
self.frameLabelCommande.close()
return
- labeltext,fonte,couleur = self.parentCommande.node.item.GetLabelText()
+ labeltext,fonte,couleur = self.parentCommande.node.item.getLabelText()
l=tr(labeltext)
li=[]
while len(l) > 25:
self.repIcon=self.appliEficas.repIcon
self.setIconePoubelle()
- if not(self.node.item.object.isvalid()) :
+ if not(self.node.item.object.isValid()) :
icon=QIcon(self.repIcon+"/ast-red-ball.png")
self.RBValide.setIcon(icon)
if self.editor.code in ['MAP','CARMELCND'] : self.bCatalogue.close()
else : self.bCatalogue.clicked.connect(self.afficheCatalogue)
- self.lineEditVal.returnPressed.connect(self.LEValeurPressed)
+ self.lineEditVal.returnPressed.connect(self.LEvaleurPressed)
self.lineEditNom.returnPressed.connect(self.LENomPressed)
self.bAvant.clicked.connect(self.afficheAvant)
self.bApres.clicked.connect(self.afficheApres)
else : self.node.tree.racine.select()
def remplit(self):
- nom=self.node.item.get_nom()
+ nom=self.node.item.getNom()
self.lineEditNom.setText(nom)
- valeur=self.node.item.get_valeur()
+ valeur=self.node.item.getValeur()
if valeur == None :
self.lineEditVal.clear()
elif type(valeur) == list :
def donnePremier(self):
self.lineEditVal.setFocus(7)
- def LEValeurPressed(self):
+ def LEvaleurPressed(self):
if self.verifiePressed() == False :
QMessageBox.warning( self,tr( "Modification Impossible"),tr( "le parametre n'est pas valide"))
nom=str(self.lineEditNom.text())
val=str(self.lineEditVal.text())
- self.node.item.set_nom(nom)
- self.node.item.set_valeur(val)
- self.node.update_texte()
+ self.node.item.setNom(nom)
+ self.node.item.setValeur(val)
+ self.node.updateTexte()
def LENomPressed(self):
- self.LEValeurPressed()
+ self.LEvaleurPressed()
def verifiePressed(self):
nomString=str(self.lineEditNom.text())
contexte={}
exec("from math import *", contexte)
- jdc=self.node.item.get_jdc()
+ jdc=self.node.item.getJdc()
for p in jdc.params :
try:
tp=p.nom+'='+str(repr(p.valeur))
for i in self.listeLE: i.close()
self.listeLE=[]
self.vScrollBar = self.scrollArea.verticalScrollBar()
- self.listeAAfficher = self.node.item.get_sd_avant_du_bon_type()
+ self.listeAAfficher = self.node.item.getSdAvantDuBonType()
if len(self.listeAAfficher) == 0 :
self.ajoutLE(0)
self.RBVoisListe.setIcon(icon)
- self.listeValeursCourantes=self.node.item.GetListeValeurs()
+ self.listeValeursCourantes=self.node.item.getListeValeurs()
if self.monSimpDef.max != "**" and self.monSimpDef.max < 7:
hauteurMax=dicoLongueur[self.monSimpDef.max]
else :
self.ajoutLineEdit()
QApplication.processEvents()
self.scrollArea.ensureWidgetVisible(self.lineEditVal1)
- self.listeValeursCourantes=self.node.item.GetListeValeurs()
+ self.listeValeursCourantes=self.node.item.getListeValeurs()
index=1
for valeur in self.listeValeursCourantes :
- val=self.politique.GetValeurTexte(valeur)
+ val=self.politique.getValeurTexte(valeur)
nomLineEdit="lineEditVal"+str(index)
if hasattr(self,nomLineEdit) :
courant=getattr(self,nomLineEdit)
if liste ==[] : return
listeVal=[]
for valeur in self.listeValeursCourantes : listeVal.append(valeur)
- validite,comm,comm2,listeRetour=self.politique.AjoutValeurs(liste,-1,listeVal)
+ validite,comm,comm2,listeRetour=self.politique.ajoutValeurs(liste,-1,listeVal)
if (comm2 != "" and comm != None) : return comm2
if validite :
self.listeValeursCourantes=self.listeValeursCourantes+listeRetour
if len(self.listeValeursCourantes) > self.monSimpDef.min :
- self.node.item.set_valeur(self.listeValeursCourantes)
+ self.node.item.setValeur(self.listeValeursCourantes)
self.reaffiche()
return None
else :
# A priori, on ne fait rien
pass
- def ajoutNValeur(self,liste) :
- for val in liste :
- i=1
- ajoute=False
- while i < self.indexDernierLabel+1:
- nomLineEdit="lineEditVal"+str(i)
- courant=getattr(self,nomLineEdit)
- valeur=courant.text()
- if valeur == None or valeur == "" :
- ajoute=True
- courant.setText(str(val))
- commentaire=self.ajout1Valeur(val)
- if (commentaire != None ):
- self.editor.affiche_infos(commentaire,Qt.red)
- courant.setText("")
- break
- else :
- i=i+1
- if ajoute : continue
- self.ajoutLineEdit(valeur=str(val))
- self.changeValeur()
+ #def ajoutNValeur(self,liste) :
+ # for val in liste :
+ # i=1
+ # ajoute=False
+ # while i < self.indexDernierLabel+1:
+ # nomLineEdit="lineEditVal"+str(i)
+ # courant=getattr(self,nomLineEdit)
+ # valeur=courant.text()
+ # if valeur == None or valeur == "" :
+ # ajoute=True
+ # courant.setText(str(val))
+ # commentaire=self.ajout1Valeur(val)
+ # if (commentaire != None ):
+ # self.editor.afficheInfos(commentaire,Qt.red)
+ # courant.setText("")
+ # break
+ # else :
+ # i=i+1
+ # if ajoute : continue
+ # self.ajoutLineEdit(valeur=str(val))
+ # self.changeValeur()
+ def ajoutNValeur(self,liste):
+ #----------------------------
+ # attention quand on charge par un fichier, on ne peut pas se contenter d ajouter N fois 1 valeur
+ # car alors le temps de verification devient prohibitif reconstructu=ion et verification a
+ # chaque valeur. d ou l ajout de ajoutNTuple a politique plusieurs
+
+
+ listeFormatee=list(liste)
+
+ min,max=self.node.item.getMinMax()
+ if self.objSimp.valeur == None : listeComplete=listeFormatee
+ else : listeComplete =self.objSimp.valeur + listeFormatee
+
+ if len(listeComplete) > max :
+ texte=tr("Nombre maximum de valeurs ")+str(max)+tr(" atteint")
+ self.editor.affiche_infos(texte,Qt.red)
+ return
+
+ validite,comm,comm2,listeRetour= self.politique.ajoutNTuple(listeComplete)
+ if not validite :
+ self.editor.affiche_infos(texte,Qt.red)
+ return
+
+ # on calcule le dernier lineedit rempli avant de changer la valeur
+ if self.objSimp.valeur != None : indexDernierRempli=len(self.objSimp.valeur)
+ else : indexDernierRempli=0
+
+ self.politique.recordValeur(listeComplete)
+
+ indexDernierRempli=0
+ while ( indexDernierRempli < len(liste) ) :
+ texte=liste[indexDernierRempli]
+ if indexDernierRempli < self.indexDernierLabel:
+ nomLineEdit="lineEditVal"+str(indexDernierRempli+1)
+ courant=getattr(self,nomLineEdit)
+ courant.setText(str(texte))
+ else :
+ self.ajoutLineEdit(texte)
+ indexDernierRempli = indexDernierRempli + 1
+
def changeValeur(self,changeDePlace=True,oblige=False):
donneFocus=None
if valeur != None and valeur != "" :
commentaire=self.ajout1Valeur(valeur)
if (commentaire != None ):
- self.editor.affiche_infos(commentaire,Qt.red)
+ self.editor.afficheInfos(commentaire,Qt.red)
courant.setText("")
donneFocus=courant
self.reaffiche()
return
else :
- self.editor.affiche_infos("")
+ self.editor.afficheInfos("")
elif donneFocus==None : donneFocus=courant
nomDernierLineEdit="lineEditVal"+str(self.indexDernierLabel)
elif self.indexDernierLabel < self.monSimpDef.max :
self.ajoutLineEdit()
if self.listeValeursCourantes == [] : return
- min,max = self.node.item.GetMinMax()
+ min,max = self.node.item.getMinMax()
if len(self.listeValeursCourantes) < self.monSimpDef.min :
- self.editor.affiche_infos(tr('nb min de valeurs : ')+str( self.monSimpDef.min))
+ self.editor.afficheInfos(tr('nb min de valeurs : ')+str( self.monSimpDef.min))
if len(self.listeValeursCourantes) < min and oblige==True: return
if len(self.listeValeursCourantes) > max : return
- self.node.item.set_valeur(self.listeValeursCourantes)
+ self.node.item.setValeur(self.listeValeursCourantes)
if len(self.listeValeursCourantes) == self.monSimpDef.max :
- self.editor.affiche_infos(tr('nb max de valeurs atteint'))
+ self.editor.afficheInfos(tr('nb max de valeurs atteint'))
self.setValide()
self.reaffiche()
self.alpha=0
self.listeCB=[]
self.listeCbRouge=[]
- self.listeValeursCourantes=node.item.GetListeValeurs()
+ self.listeValeursCourantes=node.item.getListeValeurs()
if self.listeValeursCourantes == None : self.listeValeursCourantes=[]
Feuille.__init__(self,node,monSimpDef,nom,objSimp,parentQt,commande)
def changeTout(self,int):
+ print ('changeTout')
if self.inhibe : return
self.inhibe=True
if not(self.CBCheck.isChecked()) :
- min,max = self.node.item.GetMinMax()
+ min,max = self.node.item.getMinMax()
if max < len(self.listeAAfficher) :
commentaire=tr('impossible de tout selectionner : max =')+str(max)
- self.editor.affiche_infos(commentaire,Qt.red)
+ self.editor.afficheInfos(commentaire,Qt.red)
self.inhibe=False
return
for i in range(len(self.listeAAfficher)):
self.changeValeur()
def setValeurs(self):
- self.listeValeursCourantes =self.node.item.get_valeur()
+ print ('setValeurs')
+ self.listeValeursCourantes =self.node.item.getValeur()
if self.listeValeursCourantes == None : self.listeValeursCourantes=[]
- #print "ds set Valeur", self.listeValeursCourantes, self.node.item.get_valeur()
+ #print "ds set Valeur", self.listeValeursCourantes, self.node.item.getValeur()
self.politique=PolitiquePlusieurs(self.node,self.editor)
self.vScrollBar = self.scrollArea.verticalScrollBar()
if hasattr(self.node.item.definition.validators,'set_MCSimp'):
obj=self.node.item.getObject()
self.node.item.definition.validators.set_MCSimp(obj)
- if self.node.item.isvalid() == 0 :
+ if self.node.item.isValid() == 0 :
liste=[]
for item in self.listeValeursCourantes:
if self.node.item.definition.validators.verif_item(item)==1:
liste.append(item)
- self.listeAAfficher=self.node.item.get_liste_possible(liste)
+ self.listeAAfficher=self.node.item.getListePossible(liste)
else:
- self.listeAAfficher=self.node.item.get_liste_possible([])
+ self.listeAAfficher=self.node.item.getListePossible([])
else :
- self.listeAAfficher=self.node.item.get_liste_possible([])
+ self.listeAAfficher=self.node.item.getListePossible([])
- if self.node.item.has_intoSug() : self.listeAAfficher=self.node.item.get_liste_possible_avecSug([])
+ if self.node.item.hasIntoSug() : self.listeAAfficher=self.node.item.getListePossibleAvecSug([])
- if self.objSimp.wait_assd() :
- self.listeAAfficher=self.node.item.get_sd_avant_du_bon_type()
+ if self.objSimp.waitAssd() :
+ self.listeAAfficher=self.node.item.getSdAvantDuBonType()
if self.listeAAfficher== None or self.listeAAfficher==[] : self.listeAAfficher=[]
#if len(self.listeAAfficher)*20 > 400 : self.setMinimumHeight(400)
#else : self.setMinimumHeight(len(self.listeAAfficher)*30)
self.PourEtreCoche=[]
- if self.objSimp.wait_assd() :
+ if self.objSimp.waitAssd() :
for concept in self.listeValeursCourantes: self.PourEtreCoche.append(concept.nom)
else :
for val in self.listeValeursCourantes: self.PourEtreCoche.append(val)
def ajoutCB(self,index,valeur=None):
+ print ('ajoutCB')
nomCB="lineEditVal"+str(index)
if hasattr(self,nomCB) : return
nouveauCB = QCheckBox(self.scrollArea)
def ajout1Valeur(self,valeur=None):
+ print ('ajout1Valeur')
if valeur == None : return
liste,validite=SaisieValeur.TraiteLEValeur(self,str(valeur))
if validite == 0 : return
if liste ==[] : return
listeVal=[]
for valeur in self.listeValeursCourantes : listeVal.append(valeur)
- validite,comm,comm2,listeRetour=self.politique.AjoutValeurs(liste,-1,listeVal)
+ validite,comm,comm2,listeRetour=self.politique.ajoutValeurs(liste,-1,listeVal)
if (comm2 != "" and comm != None) : return comm2
if validite :
self.listeValeursCourantes=self.listeValeursCourantes+listeRetour
def changeValeur(self):
+ print ('changeValeur')
if self.inhibe == True: return
if hasattr(self,'LEFiltre') :self.noircirResultatFiltre()
self.listeValeursCourantesAvant=self.listeValeursCourantes
if valeur != None and valeur != "" :
commentaire=self.ajout1Valeur(valeur)
if (commentaire != None ):
- self.editor.affiche_infos(commentaire,Qt.red)
+ self.editor.afficheInfos(commentaire,Qt.red)
self.listeValeursCourantesAvant=self.listeValeursCourantes
self.setValeurs()
- min,max = self.node.item.GetMinMax()
+ min,max = self.node.item.getMinMax()
if len(self.listeValeursCourantes) < min :
- self.editor.affiche_infos(tr("Nombre minimal de valeurs : ") + str(min),Qt.red)
+ self.editor.afficheInfos(tr("Nombre minimal de valeurs : ") + str(min),Qt.red)
elif len(self.listeValeursCourantes) > max :
- self.editor.affiche_infos(tr("Nombre maximal de valeurs : ") + str(max),Qt.red)
+ self.editor.afficheInfos(tr("Nombre maximal de valeurs : ") + str(max),Qt.red)
- if self.listeValeursCourantes== [] : self.node.item.set_valeur([])
- else : self.node.item.set_valeur(self.listeValeursCourantes)
+ if self.listeValeursCourantes== [] : self.node.item.setValeur([])
+ else : self.node.item.setValeur(self.listeValeursCourantes)
# Exception pour PSEN
- if min==0 and self.listeValeursCourantes== []: self.node.item.set_valeur([])
+ if min==0 and self.listeValeursCourantes== []: self.node.item.setValeur([])
self.setValide()
def prepareListeResultatFiltre(self):
+ print ('prepareListeResultatFiltre')
filtre=str(self.LEFiltre.text())
for cb in self.listeCB:
texte=cb.text()
self.listeCbRouge.append(cb)
def prepareListeResultat(self):
+ print ('prepareListeResultat')
self.clearAll()
self.setValeurs()
def clearAll(self):
+ print ('clearAll')
for cb in self.listeCB :
cb.setText("")
GereListe.__init__(self)
#self.finCommentaireListe()
self.gereIconePlier()
- self.listeValeursCourantes=self.node.item.GetListeValeurs()
+ self.listeValeursCourantes=self.node.item.getListeValeurs()
try :
self.maCommande.listeAffichageWidget.append(self.lineEditVal1)
except :
for i in self.listeLE: i.close()
self.listeLE=[]
self.vScrollBar = self.scrollArea.verticalScrollBar()
- self.listeValeursCourantes=self.node.item.GetListeValeurs()
+ self.listeValeursCourantes=self.node.item.getListeValeurs()
if hasattr(self.node.item.definition.validators,'set_MCSimp'):
obj=self.node.item.getObject()
self.node.item.definition.validators.set_MCSimp(obj)
- if self.node.item.isvalid() == 0 :
+ if self.node.item.isValid() == 0 :
liste=[]
for item in self.listeValeursCourantes:
if self.node.item.definition.validators.verif_item(item)==1: liste.append(item)
- self.listeAAfficher=self.node.item.get_liste_possible(liste)
+ self.listeAAfficher=self.node.item.getListePossible(liste)
else:
- self.listeAAfficher=self.node.item.get_liste_possible([])
+ self.listeAAfficher=self.node.item.getListePossible([])
else :
- self.listeAAfficher=self.node.item.get_liste_possible(self.listeValeursCourantes)
+ self.listeAAfficher=self.node.item.getListePossible(self.listeValeursCourantes)
if self.listeAAfficher==[] :
self.ajoutLE(0)
def setValeurs(self,first=True):
- self.listeValeursCourantes=self.node.item.GetListeValeurs()
+ self.listeValeursCourantes=self.node.item.getListeValeurs()
if first :
if self.monSimpDef.max == "**" or self.monSimpDef.max == float('inf') : aConstruire=7
else : aConstruire=self.monSimpDef.max
if liste ==[] : return
listeVal=[]
- self.listeValeursCourantes=self.node.item.GetListeValeurs()
- min,max = self.node.item.GetMinMax()
+ self.listeValeursCourantes=self.node.item.getListeValeurs()
+ min,max = self.node.item.getMinMax()
if len(self.listeValeursCourantes) +1 > max :
- self.editor.affiche_infos(tr("Nombre maximal de valeurs : ") + str(max),Qt.red)
+ self.editor.afficheInfos(tr("Nombre maximal de valeurs : ") + str(max),Qt.red)
return
else :
- self.editor.affiche_infos("")
+ self.editor.afficheInfos("")
affiche=False
for i in range(1,self.indexDernierLabel+1):
liste,validite=SaisieValeur.TraiteLEValeur(self,str(valeur))
listeVal.append(str(valeur))
- validite,comm,comm2,listeRetour=self.politique.AjoutValeurs(listeVal,-1,[])
+ validite,comm,comm2,listeRetour=self.politique.ajoutValeurs(listeVal,-1,[])
- self.listeValeursCourantes=self.node.item.GetListeValeurs()
- min,max = self.node.item.GetMinMax()
+ self.listeValeursCourantes=self.node.item.getListeValeurs()
+ min,max = self.node.item.getMinMax()
if len(self.listeValeursCourantes) < min :
- self.editor.affiche_infos(tr("Nombre minimal de valeurs : ") + str(min),Qt.red)
+ self.editor.afficheInfos(tr("Nombre minimal de valeurs : ") + str(min),Qt.red)
else :
- self.editor.affiche_infos("")
+ self.editor.afficheInfos("")
if len(listeRetour) == 0 :
- self.node.item.set_valeur(None)
+ self.node.item.setValeur(None)
elif validite :
- self.node.item.set_valeur(listeRetour)
+ self.node.item.setValeur(listeRetour)
else :
commentaire=comm+" "+comm2
- self.editor.affiche_infos(commentaire,Qt.red)
+ self.editor.afficheInfos(commentaire,Qt.red)
self.setValide()
#
def rendVisibleLigneRE(self):
self.parentQt.commandesLayout.insertWidget(-1,self)
self.AAfficher=self.lineEditVal
self.maCommande.listeAffichageWidget.append(self.lineEditVal)
- if self.node.item.has_into() :
+ if self.node.item.hasInto() :
self.lineEditVal.setReadOnly(True)
self.lineEditVal.setStyleSheet("background:rgb(235,235,235);\n")
self.lineEditVal.setToolTip("Ensemble discret de valeurs possibles, pas de Saisie Manuelle")
def setValeurs(self):
- self.listeValeursCourantes=self.node.item.GetListeValeurs()
+ self.listeValeursCourantes=self.node.item.getListeValeurs()
if self.listeValeursCourantes != [] : self.lineEditVal.setText(str(self.listeValeursCourantes))
else : self.lineEditVal.setText("")
self.politique=PolitiquePlusieurs(self.node,self.editor)
listeValeur=[]
for v in listeValeursBrutes:
if v == None or pattern_blanc.match(v) :
- self.editor.affiche_infos(str(listeValeur)+' Valeurs saisies incorrectes',Qt.red)
+ self.editor.afficheInfos(str(listeValeur)+' Valeurs saisies incorrectes',Qt.red)
return
liste,validite=SaisieValeur.TraiteLEValeur(self,str(v))
if not validite :
- self.editor.affiche_infos(str(listeValeur) +' Valeurs saisies incorrectes',Qt.red)
+ self.editor.afficheInfos(str(listeValeur) +' Valeurs saisies incorrectes',Qt.red)
return
listeValeur.append(liste[0])
- validite,comm,comm2,listeRetour=self.politique.AjoutValeurs(listeValeur,-1,[])
+ validite,comm,comm2,listeRetour=self.politique.ajoutValeurs(listeValeur,-1,[])
if validite :
- self.node.item.set_valeur(listeValeur)
- self.node.item.isvalid()
+ self.node.item.setValeur(listeValeur)
+ self.node.item.isValid()
self.setValeurs()
else :
- self.editor.affiche_infos(str(listeValeur) + ' ' +comm,Qt.red)
+ self.editor.afficheInfos(str(listeValeur) + ' ' +comm,Qt.red)
self.lineEditVal.setText('')
class MonWidgetPlusieursPlieASSD (MonWidgetPlusieursPlie):
self.lineEditVal.setReadOnly(True)
def setValeurs(self):
- self.listeValeursCourantes=self.node.item.GetListeValeurs()
+ self.listeValeursCourantes=self.node.item.getListeValeurs()
self.politique=PolitiquePlusieurs(self.node,self.editor)
if self.listeValeursCourantes == [] : self.lineEditVal.setText(""); return
txt="["
from Tuple3 import Ui_Tuple3
+#--------------------------
class TupleCustom(object) :
+#--------------------------
+
def __init__(self,tailleTuple,parent,parentQt,index):
+ #-------------------------------------------------
QWidget.__init__(self,parent)
self.setupUi(self)
self.tailleTuple=tailleTuple
def valueChange(self):
+ #----------------------
+
listeVal=[]
-
for i in range(self.tailleTuple):
nomLE="lineEditVal_"+str(i+1)
courant=getattr(self,nomLE)
if str(val)=="" or val==None :
if not self.inFocusOutEvent : courant.setFocus()
return
+
try :
valeur=eval(val,{})
except :
try :
- d=self.parentQt.objSimp.jdc.get_contexte_avant(self.parentQt.objSimp. etape)
+ d=self.parentQt.objSimp.jdc.getContexte_avant(self.parentQt.objSimp. etape)
valeur=eval(val,d)
except :
valeur=val
def setValeur(self,value):
+ #----------------------
+
listeVal=[]
valeurNulle=True
for i in range(self.tailleTuple):
valeur=eval(val,{})
except :
try :
- d=self.parentQt.objSimp.jdc.get_contexte_avant(self.parentQt.objSimp. etape)
+ d=self.parentQt.objSimp.jdc.getContexte_avant(self.parentQt.objSimp. etape)
valeur=eval(val,d)
except :
valeur=val
else : self.valeur=listeVal
def getValeur(self):
+ #----------------------
return self.valeur
def text(self):
+ #--------------
return self.valeur
def setText(self,value):
+ #-----------------------
self.setValeur(value)
def clean(self):
+ #-------------------
self.valeur=None
for i in range(self.tailleTuple):
nomLE="lineEditVal_"+str(i+1)
courant.setText("")
def finCommentaire(self):
+ #-------------------
return self.finCommentaireListe()
+#-------------------------------------------------
class TupleCustom2(QWidget,Ui_Tuple2,TupleCustom):
+#-------------------------------------------------
+
def __init__(self,tailleTuple,parent,parentQt,index):
+ #-------------------
TupleCustom.__init__(self,tailleTuple,parent,parentQt,index)
+#-------------------------------------------------
class TupleCustom3(QWidget,Ui_Tuple3,TupleCustom):
+#-------------------------------------------------
+
def __init__(self,tailleTuple,parent,parentQt,index):
+ #-----------------------------------------------------
TupleCustom. __init__(self,tailleTuple,parent,parentQt,index)
-# ---------------------------- #
+# -------------------------------------------- #
class MonWidgetPlusieursTuple(Feuille,GereListe):
+# -------------------------------------------- #
def __init__(self,node,monSimpDef,nom,objSimp,parentQt,commande):
+ #-----------------------------------------------------
+
self.indexDernierLabel=0
self.nomLine="TupleVal"
self.listeAffichageWidget=[]
self.finCommentaireListe()
self.politique=PolitiquePlusieurs(self.node,self.editor)
self.parentQt.commandesLayout.insertWidget(-1,self)
+
if sys.platform[0:5]!="linux":
repIcon=self.node.editor.appliEficas.repIcon
fichier=os.path.join(repIcon, 'arrow_up.png')
def ajoutLineEdit(self,valeur=None,inInit=False):
+ #------------------------------------------------
self.indexDernierLabel=self.indexDernierLabel+1
nomLineEdit=self.nomLine+str(self.indexDernierLabel)
if hasattr(self,nomLineEdit) :
self.listeAffichageWidget.append(nouveauLE.lineEditVal_1)
self.listeAffichageWidget.append(nouveauLE.lineEditVal_2)
if self.nbValeurs == 3 : self.listeAffichageWidget.append(nouveauLE.lineEditVal_3)
+
self.etablitOrdre()
# deux lignes pour que le ensureVisible fonctionne
if inInit==False :QTimer.singleShot(1, self.rendVisibleLigne)
def etablitOrdre(self):
+ # ---------------------
i=0
while(i +1 < len(self.listeAffichageWidget)):
self.listeAffichageWidget[i].setFocusPolicy(Qt.StrongFocus)
def setValeurs(self):
+ # ---------------------
self.RBListePush()
- valeurs=self.node.item.get_valeur()
- min,max=self.node.item.GetMinMax()
+ valeurs=self.node.item.getValeur()
+ min,max=self.node.item.getMinMax()
if max == "**" or max > 5 : aCreer=5
else : aCreer=max
for i in range(len(valeurs),aCreer) : self.ajoutLineEdit(inInit=True)
def rendVisibleLigne(self):
+ # -------------------------
QApplication.processEvents()
self.estVisible.setFocus(True)
self.scrollArea.ensureWidgetVisible(self.estVisible,0,0)
def changeValeur(self,changeDePlace=False,oblige=True):
+ # -----------------------------------------------------
#Pour compatibilite signature
+
aLeFocus=self.focusWidget()
listeComplete=[]
-
libre=False
for i in range(self.indexDernierLabel) :
nom=self.nomLine+str(i+1)
if valeurTuple == None or valeurTuple== "":
libre=True
continue
- validite,comm,comm2,listeRetour= self.politique.AjoutTuple(valeurTuple,listeComplete)
+ validite,comm,comm2,listeRetour= self.politique.ajoutTuple(valeurTuple,listeComplete)
if not validite:
if comm2 != '' : comm += " " + comm2
- self.editor.affiche_infos(comm+" "+str(self.objSimp.definition.validators.typeDesTuples),Qt.red)
+ self.editor.afficheInfos(comm+" "+str(self.objSimp.definition.validators.typeDesTuples),Qt.red)
return
listeComplete.append(tuple(courant.valeur))
if listeComplete == [] : listeComplete=None
- self.node.item.set_valeur(listeComplete)
+ self.node.item.setValeur(listeComplete)
if changeDePlace : return
- min,max=self.node.item.GetMinMax()
- if self.indexDernierLabel == max : self.editor.affiche_infos(tr('Nb maximum de valeurs atteint'))
+ min,max=self.node.item.getMinMax()
+ if self.indexDernierLabel == max : self.editor.afficheInfos(tr('Nb maximum de valeurs atteint'))
if self.indexDernierLabel < max and libre==False :
self.ajoutLineEdit()
self.listeAffichageWidget[-2].setFocus(True)
pass
def ajoutNValeur(self,liste):
+ #----------------------------
+ # attention quand on charge par un fichier, on ne peut pas se contenter d ajouter N fois 1 valeur
+ # car alors le temps de verification devient prohibitif reconstructu=ion et verification a
+ # chaque valeur. d ou l ajout de ajoutNTuple a politique plusieurs
+
if len(liste)%self.nbValeurs != 0 :
texte="Nombre incorrect de valeurs"
- self.editor.affiche_infos(tr(texte),Qt.red)
+ self.editor.afficheInfos(tr(texte),Qt.red)
+ return
+
i=0
- min,max=self.node.item.GetMinMax()
- if self.objSimp.valeur == None : l = len(liste) and self.objSimp.valeur
- else : l = len(liste)+len(self.objSimp.valeur)
- if l > max :
+ longueur=len(liste)//self.nbValeurs
+ increment=self.nbValeurs
+ listeFormatee=[liste[k*increment:(k+1)*increment] for k in range(longueur)]
+ listeFormatee=tuple(listeFormatee)
+
+ min,max=self.node.item.getMinMax()
+ if self.objSimp.valeur == None : listeComplete=listeFormatee
+ else : listeComplete =self.objSimp.valeur + listeFormatee
+
+ if len(listeComplete) > max :
texte=tr("Nombre maximum de valeurs ")+str(max)+tr(" atteint")
- self.editor.affiche_infos(texte,Qt.red)
+ self.editor.afficheInfos(texte,Qt.red)
+ return
+
+ validite,comm,comm2,listeRetour= self.politique.ajoutNTuple(listeComplete)
+ if not validite :
+ self.editor.afficheInfos(texte,Qt.red)
return
+
+ # on calcule le dernier lineedit rempli avant de changer la valeur
+ if self.objSimp.valeur != None : indexDernierRempli=len(self.objSimp.valeur)
+ else : indexDernierRempli=0
+
+ self.politique.recordValeur(listeComplete)
+
while ( i < len(liste) ) :
- if self.objSimp.valeur != None : indexDernierRempli=len(self.objSimp.valeur)
- else : indexDernierRempli=0
try :
t=tuple(liste[i:i+self.nbValeurs])
- i=i+self.nbValeurs
except:
t=tuple(liste[i:len(liste)])
+ i=i+self.nbValeurs
if indexDernierRempli < self.indexDernierLabel:
nomLineEdit=self.nomLine+str(indexDernierRempli+1)
LEARemplir=getattr(self,nomLineEdit)
LEARemplir.lineEditVal_1.setText(str(t[0]))
LEARemplir.lineEditVal_2.setText(str(t[1]))
if self.nbValeurs== 3 : LEARemplir.lineEditVal_3.setText(str(t[2]))
- LEARemplir.valueChange()
else :
self.ajoutLineEdit(t,False)
- nomLineEdit=self.nomLine+str(self.indexDernierLabel)
- LEARemplir=getattr(self,nomLineEdit)
- LEARemplir.valueChange()
+ indexDernierRempli = indexDernierRempli + 1
+
def RBListePush(self):
+ #----------------------
# PN a rendre generique avec un truc tel prerempli
+ # pour l instant specifique PSEN
+
if self.editor.code == 'VP' : return
if self.objSimp.valeur != None and self.objSimp.valeur != [] : return
if not hasattr(self.editor.readercata.cata[0],'sd_ligne') : self.editor.readercata.cata[0].sd_ligne=None
val.append((valeur,0))
except :
pass
- self.node.item.set_valeur(val)
+ self.node.item.setValeur(val)
if self.objSimp.definition.validators.typeDesTuples[0]==self.editor.readercata.cata[0].sd_generateur :
val=[]
if hasattr(self.objSimp.jdc,'MachineDico'):
val.append((valeur,0))
except :
pass
- self.node.item.set_valeur(val)
+ self.node.item.setValeur(val)
if self.objSimp.definition.validators.typeDesTuples[0]==self.editor.readercata.cata[0].sd_transfo :
val=[]
if hasattr(self.objSimp.jdc,'TransfoDico'):
val.append((valeur,0))
except :
pass
- self.node.item.set_valeur(val)
+ self.node.item.setValeur(val)
if self.objSimp.definition.validators.typeDesTuples[0]==self.editor.readercata.cata[0].sd_charge :
val=[]
if hasattr(self.objSimp.jdc,'LoadDico'):
val.append((valeur,0))
except :
pass
- self.node.item.set_valeur(val)
+ self.node.item.setValeur(val)
if self.objSimp.definition.validators.typeDesTuples[0]==self.editor.readercata.cata[0].sd_moteur :
val=[]
if hasattr(self.objSimp.jdc,'MotorDico'):
val.append((valeur,0))
except :
pass
- self.node.item.set_valeur(val)
+ self.node.item.setValeur(val)
def setValeursApresBouton(self):
- if self.objSimp.get_valeur()==None : return
- valeur=self.objSimp.get_valeur()
+ if self.objSimp.getValeur()==None : return
+ valeur=self.objSimp.getValeur()
if not(type(valeur) == str) : valeur=str(valeur)
try :
self.dict_bouton[valeur].setChecked(True)
for valeur in self.dict_bouton:
if self.dict_bouton[valeur].isChecked():
#print "dans boutonclic is checked", valeur, type(valeur)
- SaisieValeur.LEValeurPressed(self,valeur)
+ SaisieValeur.LEvaleurPressed(self,valeur)
self.reaffiche()
def __init__(self,node,monSimpDef,nom,objSimp,parentQt,commande):
#print "dans le init de MonWidgetRadioButtonSD",self
- self.maListeDeValeur=node.item.get_sd_avant_du_bon_type()
+ self.maListeDeValeur=node.item.getSdAvantDuBonType()
MonWidgetRadioButtonCommun.__init__(self,node,monSimpDef,nom,objSimp,parentQt,commande)
def setMaxI(self):
def initLBSDCO(self):
- listeNomsSDCO = self.node.item.get_sd_avant_du_bon_type()
+ listeNomsSDCO = self.node.item.getSdAvantDuBonType()
for aSDCO in listeNomsSDCO:
self.LBSDCO.insertItem( 1,aSDCO)
- valeur = self.node.item.get_valeur()
+ valeur = self.node.item.getValeur()
if valeur != "" and valeur != None :
self.LESDCO.setText(str(valeur.nom))
"""
nomConcept=str(self.LBSDCO.currentItem().text())
self.LESDCO.clear()
- self.editor.init_modif()
- anc_val = self.node.item.get_valeur()
- test_CO=self.node.item.is_CO(anc_val)
+ self.editor.initModif()
+ anc_val = self.node.item.getValeur()
+ test_CO=self.node.item.isCO(anc_val)
- valeur,validite=self.node.item.eval_valeur(nomConcept)
- test = self.node.item.set_valeur(valeur)
+ valeur,validite=self.node.item.evalValeur(nomConcept)
+ test = self.node.item.setValeur(valeur)
if not test :
commentaire = tr("impossible d'evaluer : ") + valeur
elif validite:
commentaire = tr("Valeur du mot-clef enregistree")
if test_CO:
# il faut egalement propager la destruction de l'ancien concept
- self.node.item.delete_valeur_co(valeur=anc_val)
- self.node.item.object.etape.get_type_produit(force=1)
- self.node.item.object.etape.parent.reset_context()
+ self.node.item.deleteValeurCo(valeur=anc_val)
+ self.node.item.object.etape.getType_produit(force=1)
+ self.node.item.object.etape.parent.resetContext()
self.LESDCO.setText(nomConcept)
else :
- commentaire = self.node.item.get_cr()
+ commentaire = self.node.item.getCr()
self.reset_old_valeur(anc_val,mess=mess)
- self.editor.affiche_infos(commentaire,Qt.red)
+ self.editor.afficheInfos(commentaire,Qt.red)
self.Commentaire.setText(tr(commentaire))
Feuille.__init__(self,node,monSimpDef,nom,objSimp,parentQt,commande)
self.parentQt.commandesLayout.insertWidget(-1,self,1)
self.setFocusPolicy(Qt.StrongFocus)
- self.lineEditVal.returnPressed.connect(self.LEValeurPressed)
+ self.lineEditVal.returnPressed.connect(self.LEvaleurPressed)
self.AAfficher=self.lineEditVal
self.maCommande.listeAffichageWidget.append(self.lineEditVal)
self.lineEditVal.focusInEvent=self.monFocusInEvent
def monFocusOutEvent(self,event):
if self.oldValeurTexte != self.lineEditVal.text():
self.oldValeurTexte= self.lineEditVal.text()
- self.LEValeurPressed()
+ self.LEvaleurPressed()
QLineEdit.focusOutEvent(self.lineEditVal,event)
#def showEvent(self, event):
def setValeurs(self):
#print ("dans setValeurs")
self.politique=PolitiqueUnique(self.node,self.editor)
- valeur=self.node.item.get_valeur()
- valeurTexte=self.politique.GetValeurTexte(valeur)
+ valeur=self.node.item.getValeur()
+ valeurTexte=self.politique.getValeurTexte(valeur)
chaine=""
if valeurTexte != None :
return commentaire
- def LEValeurPressed(self):
+ def LEvaleurPressed(self):
# pour les soucis d encoding
try :
if str(self.lineEditVal.text())=="" or str(self.lineEditVal.text())==None : return
except : pass
- SaisieValeur.LEValeurPressed(self)
+ SaisieValeur.LEvaleurPressed(self)
self.parentQt.donneFocus()
self.setValeurs()
self.reaffiche()
#if self.objSimp.parent.nom == "MODEL" :
- # if self.objSimp.isvalid():
+ # if self.objSimp.isValid():
# self.objSimp.parent.change_fichier="1"
#self.node.item.parent.build_include(None,"")
self.AAfficher=self.RBTrue
def setValeurs(self):
- valeur=self.node.item.get_valeur()
+ valeur=self.node.item.getValeur()
if valeur == None : return
if valeur == True : self.RBTrue.setChecked(True)
if valeur == False : self.RBFalse.setChecked(True)
def boutonTrueClic(self):
- SaisieValeur.LEValeurPressed(self,True)
+ SaisieValeur.LEvaleurPressed(self,True)
self.reaffiche()
def boutonFalseClic(self):
- SaisieValeur.LEValeurPressed(self,False)
+ SaisieValeur.LEvaleurPressed(self,False)
self.reaffiche()
self.setFocusPolicy(Qt.StrongFocus)
self.LEImag.returnPressed.connect(self.LEImagRPressed)
self.LEReel.returnPressed.connect(self.LEReelRPressed)
- self.RBRI.clicked.connect(self.ValeurPressed )
- self.RBMP.clicked.connect(self.ValeurPressed )
+ self.RBRI.clicked.connect(self.valeurPressed )
+ self.RBMP.clicked.connect(self.valeurPressed )
self.LEComp.returnPressed.connect(self.LECompRPressed)
self.maCommande.listeAffichageWidget.append(self.LEComp)
#self.maCommande.listeAffichageWidget.append(self.RBRI)
def setValeurs(self):
self.politique=PolitiqueUnique(self.node,self.editor)
- valeur=self.node.item.get_valeur()
+ valeur=self.node.item.getValeur()
if valeur == None or valeur == '' : return
if type(valeur) not in (list,tuple) :
self.LEComp.setText(str(valeur))
v=eval(valeur,d)
except :
commentaire=tr("expression invalide")
- self.editor.affiche_infos(commentaire,Qt.red)
+ self.editor.afficheInfos(commentaire,Qt.red)
return
try :
i=v.imag
- self.editor.affiche_infos(commentaire)
- self.ValeurPressed()
+ self.editor.afficheInfos(commentaire)
+ self.valeurPressed()
except :
commentaire=tr("l expression n est pas de la forme a+bj")
- self.editor.affiche_infos(commentaire,Qt.red)
+ self.editor.afficheInfos(commentaire,Qt.red)
def LEReelRPressed(self):
self.LEComp.clear()
valeur = str(self.LEReel.text())
try :
a=locale.atof(valeur)
- self.editor.affiche_infos(commentaire)
+ self.editor.afficheInfos(commentaire)
except :
commentaire=tr("expression invalide")
- self.editor.affiche_infos(commentaire,Qt.red)
- if self.LEImag.text()!="" : self.ValeurPressed()
+ self.editor.afficheInfos(commentaire,Qt.red)
+ if self.LEImag.text()!="" : self.valeurPressed()
def LEImagRPressed(self):
self.LEComp.clear()
valeur = str(self.LEImag.text())
try :
a=locale.atof(valeur)
- self.editor.affiche_infos(commentaire)
+ self.editor.afficheInfos(commentaire)
except :
commentaire=tr("expression invalide")
- self.editor.affiche_infos(commentaire,Qt.red)
- if self.LEReel.text()!="" : self.ValeurPressed()
+ self.editor.afficheInfos(commentaire,Qt.red)
+ if self.LEReel.text()!="" : self.valeurPressed()
def finCommentaire(self):
commentaire="valeur de type complexe"
v=eval(valeur,d)
except :
commentaire=tr("expression invalide")
- self.editor.affiche_infos(commentaire,Qt.red)
+ self.editor.afficheInfos(commentaire,Qt.red)
return None
try :
i=v.imag
except :
commentaire=tr("expression n est pas de la forme a+bj")
- self.editor.affiche_infos(commentaire,Qt.red)
+ self.editor.afficheInfos(commentaire,Qt.red)
return None
return v
- def ValeurPressed(self):
+ def valeurPressed(self):
if self.LEComp.text()== "" and (self.LEReel.text()=="" or self.LEImag.text()=="") :
return
if self.LEComp.text()== "" : valeur = self.getValeurRI()
else :
if self.LEReel.text() != "" or self.LEImag.text() != "" :
commentaire=tr("entrer une seule valeur SVP")
- self.editor.affiche_infos(commentaire,Qt.red)
+ self.editor.afficheInfos(commentaire,Qt.red)
return
valeur= self.getValeurComp()
- self.politique.RecordValeur(valeur)
+ self.politique.recordValeur(valeur)
self.reaffiche()
self.parentQt.donneFocus()
l.append("RI")
else :
commentaire=tr("saisir le type de complexe")
- self.editor.affiche_infos(commentaire,Qt.red)
+ self.editor.afficheInfos(commentaire,Qt.red)
return None
try :
l.append(locale.atof(str(self.LEReel.text())))
self.parentQt.commandesLayout.insertWidget(-1,self,1)
self.setFocusPolicy(Qt.StrongFocus)
self.politique=PolitiqueUnique(self.node,self.editor)
- self.lineEditVal.returnPressed.connect(self.LEValeurPressed)
+ self.lineEditVal.returnPressed.connect(self.LEvaleurPressed)
self.AAfficher=self.lineEditVal
self.maCommande.listeAffichageWidget.append(self.lineEditVal)
- def LEValeurPressed(self):
+ def LEvaleurPressed(self):
if str(self.lineEditVal.text())=="" or str(self.lineEditVal.text())==None : return
- SaisieValeur.LEValeurPressed(self)
+ SaisieValeur.LEvaleurPressed(self)
self.parentQt.donneFocus()
self.setValeurs()
self.reaffiche()
def setValeurs(self):
- valeur=self.node.item.get_valeur()
+ valeur=self.node.item.getValeur()
if valeur != None : self.lineEditVal.setText(str(valeur))
self.setFocusPolicy(Qt.StrongFocus)
def setValeurs(self):
- valeur=self.node.item.get_valeur()
+ valeur=self.node.item.getValeur()
for i in range(self.nbValeurs) :
nomLineEdit="lineEditVal"+str(i+1)
courant=getattr(self,nomLineEdit)
def valeursPressed(self):
aLeFocus=self.focusWidget()
- self.editor.affiche_infos("")
+ self.editor.afficheInfos("")
texteValeur=""
for i in range(self.nbValeurs) :
nomLineEdit="lineEditVal"+str(i+1)
else : s=s+'"'
courant.setText(s)
texteValeur+=str(courant.text())
+ print (texteValeur)
if i+1 != self.nbValeurs : texteValeur+=','
- validite,commentaire=self.politique.RecordValeur(texteValeur)
- if not validite:self.editor.affiche_infos(commentaire+" "+str(self.objSimp.definition.validators.typeDesTuples),Qt.red)
+ validite,commentaire=self.politique.recordValeur(texteValeur)
+ if not validite:self.editor.afficheInfos(commentaire+" "+str(self.objSimp.definition.validators.typeDesTuples),Qt.red)
# Passage au champ suivant
nom=aLeFocus.objectName()[11:]
self.maCommande.listeAffichageWidget.append(self.LESDCO)
self.AAficher=self.LESDCO
- valeur = self.node.item.get_valeur()
+ valeur = self.node.item.getValeur()
if valeur != "" and valeur != None : self.LESDCO.setText(valeur.nom)
self.connect(self.LESDCO,SIGNAL("returnPressed()"),self.LESDCOReturnPressed)
self.node=node
self.parent=parent
- def TesteUneValeur(self,valeurentree):
+ def testeUneValeur(self,valeurentree):
commentaire = None
- valeur,validite=self.node.item.eval_valeur(valeurentree)
+ valeur,validite=self.node.item.evalValeur(valeurentree)
if not validite :
commentaire = "impossible d'evaluer : %s " %repr(valeurentree)
return valeur,validite,commentaire
- if self.node.item.wait_TXM() and not( type(valeur) == str) : valeur=str(valeur)
+ if self.node.item.waitTxm() and not( type(valeur) == str) : valeur=str(valeur)
testtype,commentaire = self.node.item.object.verif_type(valeur)
if not testtype :
return valeur,0,commentaire
- valide=self.node.item.valide_item(valeur)
+ valide=self.node.item.valideItem(valeur)
if type(valide) == tuple:
validite,commentaire=valide
else :
if not validite and commentaire is None:
commentaire = "impossible d'evaluer : %s " %repr(valeurentree)
+ print ('ds testeUneValeur', valeur, validite, commentaire)
return valeur, validite, commentaire
# ----------------------------------------------------------------------------------------
# Methodes utilisees pour la manipulation des items en notation scientifique
# a mettre au point
# ----------------------------------------------------------------------------------------
- def SetValeurTexte(self,texteValeur) :
+ def setValeurTexte(self,texteValeur) :
try :
if "R" in self.node.item.object.definition.type:
if texteValeur[0] != "'":
clef=eval(texteValeur)
if str(clef) != str(texteValeur) :
- self.node.item.object.init_modif()
+ self.node.item.object.initModif()
clefobj=self.node.item.object.GetNomConcept()
if not clefobj in self.parent.appliEficas.dict_reels:
self.parent.appliEficas.dict_reels[clefobj] = {}
except:
pass
- def GetValeurTexte(self,valeur) :
+ def getValeurTexte(self,valeur) :
valeurTexte=valeur
if valeur == None : return valeur
from decimal import Decimal
if isinstance(valeur,Decimal) :
- if self.node.wait_TXM() and not self.is_param(valeur) : return "'"+str(valeur)+"'"
+ if self.node.waitTxm() and not self.isParam(valeur) : return "'"+str(valeur)+"'"
else : return(valeur)
if "R" in self.node.item.object.definition.type:
clefobj=self.node.item.object.GetNomConcept()
else :
if str(valeur).find('.') == -1 and str(valeur).find('e') == -1 and str(valeur).find('E'):
# aucun '.' n'a ete trouve dans valeur --> on en rajoute un a la fin
- if (self.is_param(valeur)):
+ if (self.isParam(valeur)):
return valeur
else:
try :
pass
return valeurTexte
- def is_param(self,valeur) :
+ def isParam(self,valeur) :
for param in self.node.item.jdc.params:
if ((repr(param) == repr(valeur)) or (str(param)==str(valeur))):
return 1
return 0
- def AjoutDsDictReel(self,texteValeur):
+ def ajoutDsDictReel(self,texteValeur):
# le try except est necessaire pour saisir les parametres
# on enleve l erreur de saisie 00 pour 0
if str(texteValeur)== '00' : return
except:
pass
- def AjoutDsDictReelEtape(self):
+ def ajoutDsDictReelEtape(self):
try:
if self.node.item.object in self.parent.appliEficas.dict_reels:
self.parent.appliEficas.dict_reels[self.node.item.sdnom]=self.parent.appliEficas.dict_reels[self.node.item.object]
def __init__(self,node,parent):
Validation.__init__(self,node,parent)
- def RecordValeur(self,valeurentree):
- if self.parent.modified == 'n' : self.parent.init_modif()
- ancienne_val = self.node.item.get_valeur()
- valeur,validite,commentaire =self.TesteUneValeur(valeurentree)
+ def recordValeur(self,valeurentree):
+ if self.parent.modified == 'n' : self.parent.initModif()
+ ancienneVal = self.node.item.getValeur()
+ valeur,validite,commentaire =self.testeUneValeur(valeurentree)
if validite and ('R' in self.node.item.object.definition.type) and not(isinstance(valeur,PARAMETRE)) :
s=valeurentree
if (s.find('.')== -1 and s.find('e')== -1 and s.find('E')==-1) : s=s+'.'
- valeur,validite,commentaire =self.TesteUneValeur(s)
+ valeur,validite,commentaire =self.testeUneValeur(s)
if validite :
- validite=self.node.item.set_valeur(valeur)
- if self.node.item.isvalid():
+ validite=self.node.item.setValeur(valeur)
+ if self.node.item.isValid():
commentaire = tr("Valeur du mot-cle enregistree")
#commentaire = "Valeur du mot-cle enregistree"
- self.SetValeurTexte(str(valeurentree))
+ self.setValeurTexte(str(valeurentree))
else:
- cr = self.node.item.get_cr()
+ cr = self.node.item.getCr()
commentaire = tr("Valeur du mot-cle non autorisee ")+cr.get_mess_fatal()
- self.node.item.set_valeur(ancienne_val)
+ self.node.item.setValeur(ancienneVal)
return validite, commentaire
#print self.parent
- def AjoutValeurs(self,listevaleur,index,listecourante):
+ def ajoutValeurs(self,listevaleur,index,listecourante):
listeRetour=[]
commentaire="Nouvelle valeur acceptee"
commentaire2=""
if not( type(listevaleur) in (list,tuple)) :
listevaleur=tuple(listevaleur)
# on verifie que la cardinalite max n a pas ete atteinte
- min,max = self.node.item.GetMinMax()
+ min,max = self.node.item.getMinMax()
if len(listecourante) + len(listevaleur) > max :
commentaire="La liste atteint le nombre maximum d'elements : "+ str(max) +" ,ajout refuse"
return False,commentaire,commentaire2,listeRetour
for valeur in listevaleur :
# On teste le type de la valeur
valeurScientifique=valeur
- valide=self.node.item.valide_item(valeur)
+ valide=self.node.item.valideItem(valeur)
if not valide :
try :
- valeur,valide=self.node.item.eval_valeur(valeur)
+ valeur,valide=self.node.item.evalValeur(valeur)
valide,commentaire2 = self.node.item.object.verif_type(valeur)
except :
#return testtype,commentaire,"",listeRetour
commentaire="Valeur "+str(valeur)+ " incorrecte : ajout a la liste refuse: On attend une chaine de caracteres < 8"
else :
commentaire="Valeur "+str(valeur)+ " incorrecte : ajout a la liste refuse"
- if commentaire2== "" :commentaire2=self.node.item.info_erreur_item()
+ if commentaire2== "" :commentaire2=self.node.item.infoErreurItem()
return valide,commentaire,commentaire2,listeRetour
# On valide la liste obtenue
- encorevalide=self.node.item.valide_liste_partielle(valeur,listecourante)
+ encorevalide=self.node.item.valideListePartielle(valeur,listecourante)
if not encorevalide :
- commentaire2=self.node.item.info_erreur_liste()
+ commentaire2=self.node.item.infoErreurListe()
# On traite le cas ou la liste n est pas valide pour un pb de cardinalite
- min,max = self.node.item.GetMinMax()
+ min,max = self.node.item.getMinMax()
if len(listecourante) + 1 >= max :
commentaire="La liste atteint le nombre maximum d'elements : "+ str(max) +" ,ajout refuse"
return valide,commentaire,commentaire2,listeRetour
commentaire=""
return valide,commentaire,commentaire2,listeRetour
# On ajoute la valeur testee a la liste courante et a la liste acceptee
- self.AjoutDsDictReel(valeurScientifique)
+ self.ajoutDsDictReel(valeurScientifique)
listecourante.insert(index,valeur)
index=index+1
listeRetour.append(valeur)
return valide,commentaire,commentaire2,listeRetour
- def AjoutTuple(self,valeurTuple,listecourante):
+ def ajoutTuple(self,valeurTuple,listecourante):
listeRetour=[]
commentaire="Nouvelle valeur acceptee"
commentaire2=""
if valeurTuple==None: return
if valeurTuple==['']: return
# On teste le type de la valeur
- valide=self.node.item.valide_item(valeurTuple)
+ valide=self.node.item.valideItem(valeurTuple)
if not valide :
try :
- valeur,valide=self.node.item.eval_valeur(valeurTuple)
- valide = self.node.item.valide_item(valeur)
+ valeur,valide=self.node.item.evalValeur(valeurTuple)
+ valide = self.node.item.valideItem(valeur)
except :
pass
if not valide:
commentaire="Valeur "+str(valeurTuple)+ " incorrecte : ajout a la liste refuse"
- commentaire2=self.node.item.info_erreur_item()
+ commentaire2=self.node.item.infoErreurItem()
return valide,commentaire,commentaire2,listeRetour
# On valide la liste obtenue
- encorevalide=self.node.item.valide_liste_partielle(valeurTuple,listecourante)
+ encorevalide=self.node.item.valideListePartielle(valeurTuple,listecourante)
if not encorevalide :
- commentaire2=self.node.item.info_erreur_liste()
+ commentaire2=self.node.item.infoErreurListe()
return valide,commentaire,commentaire2,listeRetour
listeRetour.append(valeurTuple)
return valide,commentaire,commentaire2,listeRetour
+
+ def ajoutNTuple(self,liste):
+ listeRetour=[]
+ commentaire="Nouvelles valeurs acceptee"
+ commentaire2=""
+ print (self.node.item.valideListePartielle)
+ valide=self.node.item.valideListePartielle(None,liste)
+ if not valide :
+ commentaire2=self.node.item.infoErreurListe()
+ return valide,commentaire,commentaire2,listeRetour
+
+ def recordValeur(self,liste,dejaValide=True):
+ ancienneVal = self.node.item.getValeur()
+ validite=self.node.item.setValeur(liste)
+ if validite : self.node.item.initModif()
+ if self.node.item.isValid():
+ commentaire = tr("Valeur du mot-cle enregistree")
+ else:
+ cr = self.node.item.getCr()
+ commentaire = tr("Valeur du mot-cle non autorisee ")+cr.get_mess_fatal()
+ self.node.item.setValeur(ancienneVal)
+ return validite, commentaire
+
+
import six
-from PyQt5.QtWidgets import QApplication, QMainWindow, QBoxLayout, QMenu, QAction, QMessageBox
+from PyQt5.QtWidgets import QApplication, QMainWindow, QGridLayout, QBoxLayout, QMenu, QAction, QMessageBox
from PyQt5.QtGui import QIcon
-from PyQt5.QtCore import Qt
+from PyQt5.QtCore import Qt, QSize
from Extensions.i18n import tr
from Extensions.eficas_exception import EficasException
self.parentMainWindow=parent
self.ihm="QT"
self.ssIhm=ssIhm
- self.top = self #(pour CONFIGURATION)
+ self.top = self #(pour maConfiguration)
self.QWParent=None #(Pour lancement sans IHM)
self.code=code
self.indice=0
if code==None: return
self.suiteTelemac=False
- if hasattr (self, 'CONFIGURATION') :
- if self.CONFIGURATION.force_langue :
+ if hasattr (self, 'maConfiguration') :
+ if self.maConfiguration.force_langue :
from .monChoixLangue import MonChoixLangue
widgetLangue = MonChoixLangue(self)
ret=widgetLangue.exec_()
- self.suiteTelemac=self.CONFIGURATION.suiteTelemac
+ self.suiteTelemac=self.maConfiguration.suiteTelemac
- if not self.salome and hasattr (self, 'CONFIGURATION') and hasattr(self.CONFIGURATION,'lang') : self.langue=self.CONFIGURATION.lang
+ if not self.salome and hasattr (self, 'maConfiguration') and hasattr(self.maConfiguration,'lang') : self.langue=self.maConfiguration.lang
from Extensions import localisation
app=QApplication
- if hasattr (self, 'CONFIGURATION') : localisation.localise(None,self.langue,translatorFichier=self.CONFIGURATION.translatorFichier)
+ if hasattr (self, 'maConfiguration') : localisation.localise(None,self.langue,translatorFichier=self.maConfiguration.translatorFichier)
self.setupUi(self)
#if parent != None : self.parentCentralWidget = parent.centralWidget()
#else : self.parentCentralWidget = None
if not self.salome :
- if hasattr (self, 'CONFIGURATION') and hasattr(self.CONFIGURATION,'taille') : self.taille=self.CONFIGURATION.taille
+ if hasattr (self, 'maConfiguration') and hasattr(self.maConfiguration,'taille') : self.taille=self.maConfiguration.taille
else : self.taille=1700
if self.code in ['MAP',] : self.resize(1440,self.height())
icon = QIcon(self.repIcon+"/parametres.png")
self.actionParametres.setIcon(icon)
+ if hasattr (self, 'maConfiguration') and self.maConfiguration.boutonDsMenuBar :
+ self.frameEntete.setMaximumSize(QSize(16777215,100))
+ self.frameEntete.setMinimumSize(QSize(0,100))
+
self.myQtab.removeTab(0)
- self.blEntete= QBoxLayout(0,self.frameEntete)
+ self.blEnteteGlob = QBoxLayout(2,self.frameEntete)
+ self.blEnteteGlob.setSpacing(0)
+ self.blEnteteGlob.setContentsMargins(0,0,0,0)
+
+ self.blEntete = QBoxLayout(0)
self.blEntete.insertWidget(0,self.toolBar)
self.blEntete.insertWidget(0,self.menubar)
+ self.blEnteteGlob.insertLayout(0,self.blEntete)
+
+
+
+ if hasattr (self, 'maConfiguration') and self.maConfiguration.boutonDsMenuBar :
+ self.blEnteteCommmande = QBoxLayout(0)
+ self.blEnteteCommmande.insertWidget(0,self.toolBarCommande)
+ self.blEnteteGlob.insertLayout(-1,self.blEnteteCommmande)
+ else :
+ self.toolBarCommande.close()
+
- if hasattr (self, 'CONFIGURATION') and self.CONFIGURATION.closeEntete==True and self.salome: self.closeEntete()
+ if hasattr (self, 'maConfiguration') and self.maConfiguration.closeEntete==True and self.salome: self.closeEntete()
eficas_root_dir = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
- #self.resize(20,20)
self.viewmanager = MyTabview(self)
self.recentMenu=QMenu(tr('&Recents'))
#self.menuFichier.insertMenu(self.actionOuvrir,self.recentMenu)
+
# actionARemplacer ne sert que pour l insert Menu
self.menuFichier.insertMenu(self.actionARemplacer ,self.recentMenu)
self.menuFichier.removeAction(self.actionARemplacer)
if self.code != None : self.construitMenu()
self.setWindowTitle(self.VERSION_EFICAS)
- #try :
- if 1 :
+ try :
+ #if 1 :
+ # print ('attention try devient if 1')
self.ouvreFichiers()
- #except EficasException, exc:
+ except EficasException, exc:
#except:
# print "je suis dans le except"
- #if self.salome == 0 : exit()
+ if self.salome == 0 : exit()
#self.adjustSize()
self.cleanPath()
from .monChoixCode import MonChoixCode
widgetChoix = MonChoixCode(self)
- ret=widgetChoix.exec_()
+ #ret=widgetChoix.exec_()
+ widgetChoix.show()
import sys
if self.code == None:return # pour le cancel de la fenetre choix code
name='prefs_'+self.code
nameConf='configuration_'+self.code
configuration=__import__(nameConf)
- self.CONFIGURATION = configuration.make_config(self,prefsCode.repIni)
+ self.maConfiguration = configuration.make_config(self,prefsCode.repIni)
self.CONFIGStyle = None
if hasattr(configuration,'make_config_style'):
self.CONFIGStyle = configuration.make_config_style(self,prefsCode.repIni)
- if hasattr (self,'CONFIGURATION') and self.CONFIGURATION.translatorFichier :
+ if hasattr (self,'maConfiguration') and self.maConfiguration.translatorFichier :
from Extensions import localisation
- localisation.localise(None,self.langue,translatorFichier=self.CONFIGURATION.translatorFichier)
+ localisation.localise(None,self.langue,translatorFichier=self.maConfiguration.translatorFichier)
+ print ('self.closeAutreCommande',self.maConfiguration.closeAutreCommande)
#PN --> pb d exception qui font planter salome
# plus supporte en python 3
#app=QApplication
repAide=os.path.dirname(os.path.abspath(__file__))
fileName='index.html'
self.docPath=repAide+"/../Aide"
- if hasattr(self,'CONFIGURATION') and hasattr(self.CONFIGURATION,'docPath') : self.docPath=self.CONFIGURATION.docPath
- if hasattr(self,'CONFIGURATION') and hasattr(self.CONFIGURATION,'fileName'):fileName=self.CONFIGURATION.fileName
+ if hasattr(self,'maConfiguration') and hasattr(self.maConfiguration,'docPath') : self.docPath=self.maConfiguration.docPath
+ if hasattr(self,'maConfiguration') and hasattr(self.maConfiguration,'fileName'):fileName=self.maConfiguration.fileName
self.fileDoc=os.path.join(self.docPath,fileName)
self.actionCode.setText(tr("Aide specifique ")+str(self.code))
if not os.path.isfile(self.fileDoc) :
def enleverSupprimer(self):
self.toolBar.removeAction(self.actionSupprimer)
- def enleverNewInclude(self):
+ def enlevernewInclude(self):
self.actionNouvel_Include.setVisible(False)
def enleverRechercherDsCatalogue(self):
def ZCRACKS(self):
- self.enleverNewInclude()
+ self.enlevernewInclude()
self.toolBar.addSeparator()
self.ajoutExecution()
def ADAO(self):
self.enleverActionsStructures()
- self.enleverNewInclude()
+ self.enlevernewInclude()
def ASTER(self) :
self.menuTraduction = self.menubar.addMenu("menuTraduction")
def CARMEL3D(self):
#if self.salome == 0 : return
- self.enleverNewInclude()
+ self.enlevernewInclude()
self.menuMesh = self.menubar.addMenu(tr("Gestion Maillage"))
self.menuMesh.setObjectName("Mesh")
self.menuMesh.addAction(self.actionChercheGrpMaille)
#self.griserActionsStructures()
def CARMELCND(self):
- self.enleverNewInclude()
+ self.enlevernewInclude()
self.enleverRechercherDsCatalogue()
self.ajoutExecution()
self.ajoutSauveExecution()
self.griserActionsStructures()
def MAP(self):
- self.enleverNewInclude()
+ self.enlevernewInclude()
self.toolBar.addSeparator()
self.ajoutExecution()
self.ajoutSauveExecution()
self.enleverActionsStructures()
self.enleverParametres()
self.enleverRechercherDsCatalogue()
- self.enleverNewInclude()
+ self.enlevernewInclude()
self.ajoutExecution()
self.ajoutN1()
self.ajoutHelpPSEN()
self.enleverActionsStructures()
self.enleverParametres()
self.enleverRechercherDsCatalogue()
- self.enleverNewInclude()
+ self.enlevernewInclude()
self.ajoutExecution()
self.ajoutIcones()
def TELEMAC(self):
self.enleverActionsStructures()
- self.enleverNewInclude()
+ self.enlevernewInclude()
self.connectRechercherDsCatalogue()
self.ajoutSortieLegere()
def lookSuiteTelemac(self):
self.enleverActionsStructures()
- self.enleverNewInclude()
+ self.enlevernewInclude()
self.enleverParametres()
self.enleverSupprimer()
self.enleverRechercherDsCatalogue()
self.connect(self.recentMenu,SIGNAL('aboutToShow()'),self.handleShowRecentMenu)
self.connect(self.action_Nouveau,SIGNAL("triggered()"),self.fileNew)
- self.connect(self.actionNouvel_Include,SIGNAL("triggered()"),self.NewInclude)
+ self.connect(self.actionNouvel_Include,SIGNAL("triggered()"),self.newInclude)
self.connect(self.actionOuvrir,SIGNAL("triggered()"),self.fileOpen)
self.connect(self.actionEnregistrer,SIGNAL("triggered()"),self.fileSave)
self.connect(self.actionEnregistrer_sous,SIGNAL("triggered()"),self.fileSaveAs)
self.connect(self.actionColler,SIGNAL("triggered()"),self.editPaste)
self.connect(self.actionSupprimer,SIGNAL("triggered()"),self.supprimer)
self.connect(self.actionRechercher,SIGNAL("triggered()"),self.rechercher)
- self.connect(self.actionDeplier_replier,SIGNAL("triggered()"),self.Deplier)
+ self.connect(self.actionDeplier_replier,SIGNAL("triggered()"),self.handleDeplier)
self.connect(self.actionRapport_de_Validation,SIGNAL("triggered()"),self.jdcRapport)
self.connect(self.actionRegles_du_JdC,SIGNAL("triggered()"),self.jdcRegles)
self.recentMenu.aboutToShow.connect(self.handleShowRecentMenu)
self.action_Nouveau.triggered.connect(self.fileNew)
- self.actionNouvel_Include.triggered.connect(self.NewInclude)
+ self.actionNouvel_Include.triggered.connect(self.newInclude)
self.actionOuvrir.triggered.connect(self.fileOpen)
self.actionEnregistrer.triggered.connect(self.fileSave)
self.actionEnregistrer_sous.triggered.connect(self.fileSaveAs)
self.actionColler.triggered.connect(self.editPaste)
self.actionSupprimer.triggered.connect(self.supprimer)
self.actionRechercher.triggered.connect(self.rechercher)
- self.actionDeplier_replier.triggered.connect(self.Deplier)
+ self.actionDeplier_replier.triggered.connect(self.handleDeplier)
self.actionRapport_de_Validation.triggered.connect(self.jdcRapport)
self.actionRegles_du_JdC.triggered.connect(self.jdcRegles)
self.actionCode.triggered.connect(self.aideCode)
- def Deplier(self):
+ def handleDeplier(self):
self.viewmanager.handleDeplier()
def ajoutCommentaire(self):
self.dir=cwd
for study in session.d_env.studies:
os.chdir(cwd)
- d=session.get_unit(study,self)
+ d=session.getUnit(study,self)
self.viewmanager.handleOpen(fichier=study["comm"],units=d)
- def get_source(self,file):
+ def getSource(self,file):
# appele par Editeur/session.py
import convert
p=convert.plugins['python']()
def sauveRecents(self) :
try :
- rep=self.CONFIGURATION.rep_user
+ rep=self.maConfiguration.rep_user
monFichier=rep+"/listefichiers_"+self.code
except :
return
def traductionV11V12(self):
from .gereTraduction import traduction
- traduction(self.CONFIGURATION.repIni,self.viewmanager,"V11V12")
+ traduction(self.maConfiguration.repIni,self.viewmanager,"V11V12")
def traductionV10V11(self):
from .gereTraduction import traduction
- traduction(self.CONFIGURATION.repIni,self.viewmanager,"V10V11")
+ traduction(self.maConfiguration.repIni,self.viewmanager,"V10V11")
def traductionV9V10(self):
from .gereTraduction import traduction
- traduction(self.CONFIGURATION.repIni,self.viewmanager,"V9V10")
+ traduction(self.maConfiguration.repIni,self.viewmanager,"V9V10")
def version(self) :
from .monVisu import DVisu
#else :
QMessageBox.critical( self, tr("Parametrage"), tr("Pas de possibilite de personnalisation de la configuration "))
return
- monOption=optionCode.Options(parent=self,modal = 0 ,configuration=self.CONFIGURATION)
+ monOption=optionCode.Options(parent=self,modal = 0 ,configuration=self.maConfiguration)
monOption.show()
def optionPdf(self) :
from monOptionsPdf import OptionPdf
- monOption=OptionPdf(parent=self,modal = 0 ,configuration=self.CONFIGURATION)
+ monOption=OptionPdf(parent=self,modal = 0 ,configuration=self.maConfiguration)
monOption.show()
def handleSortieLegere(self):
self.viewmanager.handleViewJdcRegles()
def gestionParam(self):
- self.viewmanager.handlegestionParam()
+ self.viewmanager.handleGestionParam()
def visuJdcPy(self):
self.viewmanager.handleViewJdcPy()
def fermeArbre(self):
self.viewmanager.fermeArbre()
- def NewInclude(self):
+ def newInclude(self):
self.viewmanager.newIncludeEditor()
def cleanPath(self):
res=self.fileExit()
if res==2 : event.ignore()
+
+ def remplitIconesCommandes(self):
+ if self.maConfiguration.boutonDsMenuBar == False : return
+ if not hasattr(self, 'readercata') : return
+ from monLayoutBouton import MonLayoutBouton
+ if hasattr(self,'monLayoutBoutonRempli') :
+ print ('double passage dans le readerCata')
+ self.monLayoutBoutonRempli.close()
+ self.monLayoutBoutonRempli=MonLayoutBouton(self)
+ #for
+ #self.toolBarCommande.close()
+
+ def handleAjoutEtape(self,nomEtape):
+ self.viewmanager.handleAjoutEtape(nomEtape)
+
if __name__=='__main__':
# Modules Eficas
- rep=os.path.abspath(os.path.join(os.path.dirname(os.path.abspath(__file__),'..','ASTER')))
+ rep=os.path.abspath(os.path.join(os.path.dirname(os.path.abspath(__file__),'..','Adao')))
sys.path.append(rep)
- from Aster import prefsCode
- if hasattr(prefsCode,'encoding'):
+ from Adao import prefs
+ from Adao import prefs_Adao
+ #if hasattr(prefsCode,'encoding'):
# Hack pour changer le codage par defaut des strings
- import sys
- reload(sys)
- sys.setdefaultencoding(prefsCode.encoding)
- del sys.setdefaultencoding
+ #import sys
+ #reload(sys)
+ #sys.setdefaultencoding(prefsCode.encoding)
+ #del sys.setdefaultencoding
# Fin hack
from Editeur import import_code
pass
- def LEValeurPressed(self,valeur=None):
+ def LEvaleurPressed(self,valeur=None):
if not hasattr(self, 'inSaisieValeur' ) : self.inSaisieValeur=False
if self.inSaisieValeur : return
self.inSaisieValeur=True
try :
nouvelleValeur=str(self.lineEditVal.text())
except UnicodeEncodeError as e :
- self.editor.affiche_infos("pb d encoding", Qt.red)
- validite,commentaire=self.politique.RecordValeur(None)
+ self.editor.afficheInfos("pb d encoding", Qt.red)
+ validite,commentaire=self.politique.recordValeur(None)
self.lineEditVal.setText('')
self.setValide()
self.inSaisieValeur=False
nouvelleValeur=valeur
if self.node.item.definition.validators != None :
if self.node.item.definition.validators.verif_item(nouvelleValeur) !=1 :
- commentaire=self.node.item.definition.validators.info_erreur_item()
- self.editor.affiche_infos(commentaire,Qt.red)
+ commentaire=self.node.item.definition.validators.infoErreurItem()
+ self.editor.afficheInfos(commentaire,Qt.red)
self.inSaisieValeur=False
return
- nouvelleValeurFormat=self.politique.GetValeurTexte(nouvelleValeur)
- validite,commentaire=self.politique.RecordValeur(nouvelleValeurFormat)
+ nouvelleValeurFormat=self.politique.getValeurTexte(nouvelleValeur)
+ validite,commentaire=self.politique.recordValeur(nouvelleValeurFormat)
if commentaire != "" :
#PNPNPNP Il faut trouver une solution pour les 2 cas
- # self.editor.affiche_infos(commentaire)
+ # self.editor.afficheInfos(commentaire)
#self.Commentaire.setText(tr(commentaire))
if validite :
- self.editor.affiche_commentaire(commentaire)
+ self.editor.afficheCommentaire(commentaire)
else :
- self.editor.affiche_infos(commentaire,Qt.red)
+ self.editor.afficheInfos(commentaire,Qt.red)
self.inSaisieValeur=False
self.setValide()
valeur=valeurBrute
# pour traiter 11.0 - 30.0 pour le CIST
- if (valeurTraitee and (type(valeurTraitee) in types.StringTypes) and (self.node.item.wait_TXM())) :
+ if (valeurTraitee and (type(valeurTraitee) in types.StringTypes) and (self.node.item.waitTxm())) :
valeur=str(valeurTraitee)
if type(valeur) in (list,tuple) :
- if self.node.item.wait_complex() :
+ if self.node.item.waitComplex() :
indice = 0
while (indice < len(valeur)):
v=valeur[indice]
indice=indice+3
except :
commentaire = tr("Veuillez entrer le complexe sous forme aster ou sous forme python")
- self.editor.affiche_infos(commentaire)
+ self.editor.afficheInfos(commentaire)
return listeValeurs,0
Lit le nom donne par l'utilisateur au concept de type CO qui doit être
la valeur du MCS courant et stocke cette valeur
"""
- self.editor.init_modif()
- anc_val = self.node.item.get_valeur()
+ self.editor.initModif()
+ anc_val = self.node.item.getValeur()
if anc_val != None:
# il faut egalement propager la destruction de l'ancien concept
- self.node.item.delete_valeur_co(valeur=anc_val)
+ self.node.item.deleteValeurCo(valeur=anc_val)
# et on force le recalcul des concepts de sortie de l'etape
- self.node.item.object.etape.get_type_produit(force=1)
+ self.node.item.object.etape.getType_produit(force=1)
# et le recalcul du contexte
- self.node.item.object.etape.parent.reset_context()
+ self.node.item.object.etape.parent.resetContext()
nomConcept = str(self.LESDCO.text())
if nomConcept == "" : return
- test,commentaire=self.node.item.set_valeur_co(nomConcept)
+ test,commentaire=self.node.item.setValeurCo(nomConcept)
if test:
commentaire=tr("Valeur du mot-clef enregistree")
- self.node.update_node_valid()
+ self.node.updateNodeValid()
else :
- cr = self.node.item.get_cr()
+ cr = self.node.item.getCr()
commentaire = tr("Valeur du mot-clef non autorisee :")+cr.get_mess_fatal()
self.code=self.QWParent.code
self.ssCode=self.appliEficas.ssCode
self.appliEficas.format_fichier='python'
- self.mode_nouv_commande=self.appliEficas.CONFIGURATION.mode_nouv_commande
self.version_code=self.QWParent.version_code
self.version_cata=None
self.fic_cata=None
- self.OpenCata()
+ self.openCata()
+ self.traiteIcones()
self.cataitem=None
- self.cree_dico_inverse()
- if self.code=="TELEMAC": self.cree_dico_CasToCata()
- #for k in self.dicoInverse:
- # genea= self.dicoInverse[k]
- # for t in genea :
- # print t[0]
- # print "\n"
+ self.creeDicoInverse()
+ if self.code=="TELEMAC": self.creeDicoCasToCata()
- def OpenCata(self):
+ def openCata(self):
"""
Ouvre le catalogue standard du code courant, cad le catalogue present
dans le repertoire Cata
self.Commandes_Ordre_Catalogue=[]
all_cata_list = []
- for catalogue in self.appliEficas.CONFIGURATION.catalogues:
+ for catalogue in self.appliEficas.maConfiguration.catalogues:
if isinstance(catalogue, CatalogDescription):
all_cata_list.append(catalogue)
elif isinstance(catalogue, tuple):
else:
# plusieurs catalogues sont disponibles : il faut demander a l'utilisateur
# lequel il veut utiliser ...
- self.ask_choix_catalogue(cata_choice_list)
+ self.askChoixCatalogue(cata_choice_list)
if self.fic_cata == None :
if self.appliEficas.salome == 0 :
self.appliEficas.close()
return
- if self.code == "ASTER" : self.determineMater()
# import du catalogue
- self.cata = self.import_cata(self.fic_cata)
+ self.cata = self.importCata(self.fic_cata)
if not self.cata :
QMessageBox.critical( self.QWParent, tr("Import du catalogue"),tr("Impossible d'importer le catalogue ")+ self.fic_cata)
self.appliEficas.close()
#
# analyse du catalogue (ordre des mots-cles)
#
- # Retrouve_Ordre_Cata_Standard fait une analyse textuelle du catalogue
- # remplace par Retrouve_Ordre_Cata_Standard_autre qui utilise une numerotation
+ # retrouveOrdreCataStandard fait une analyse textuelle du catalogue
+ # remplace par retrouveOrdreCataStandardAutre qui utilise une numerotation
# des mots cles a la creation
- self.Retrouve_Ordre_Cata_Standard_autre()
- if self.mode_nouv_commande== "initial" : self.Retrouve_Ordre_Cata_Standard()
+ self.retrouveOrdreCataStandardAutre()
+ if self.appliEficas.maConfiguration.modeNouvCommande == "initial" : self.retrouveOrdreCataStandard()
if hasattr(self.cata, 'Ordre_Des_Commandes') : self.Ordre_Des_Commandes=self.cata.Ordre_Des_Commandes
else : self.Ordre_Des_Commandes=None
#
# traitement des clefs documentaires
#
- if self.code == "ASTER" : self.traite_clefs_documentaires()
self.cata=(self.cata,)
self.titre=self.VERSION_EFICAS+" "+tr( " avec le catalogue ") + os.path.basename(self.fic_cata)
self.appliEficas.titre=self.titre
self.QWParent.titre=self.titre
- def determineMater(self) :
- # Determinination du repertoire materiau
- v_codeSansPoint=self.version_code
- if v_codeSansPoint == None : return
- v_codeSansPoint=re.sub("\.","",v_codeSansPoint)
- chaine="rep_mat_"+v_codeSansPoint
- if hasattr(self.appliEficas.CONFIGURATION,chaine):
- a=getattr(self.appliEficas.CONFIGURATION,chaine)
- else :
- try :
- a=self.appliEficas.CONFIGURATION.dRepMat[self.version_code]
- except :
- if self.code == "ASTER" :
- print ("Probleme avec le repertoire materiau")
- a='.'
- self.appliEficas.CONFIGURATION.rep_mat=a
-
- def import_cata(self,cata):
+
+ def importCata(self,cata):
"""
Realise l'import du catalogue dont le chemin d'acces est donne par cata
"""
del sys.modules[k]
mesScriptsNomFichier='mesScripts_'+self.code.upper()
- if self.code == "ASTER" :
- self.appliEficas.rep_scripts=os.path.join(rep_cata,nom_cata)
- sys.path[:0] = [self.appliEficas.rep_scripts]
- try :
- self.appliEficas.mesScripts[self.code]=__import__(mesScriptsNomFichier)
- except:
- pass
- sys.path=sys.path[1:]
- else :
- try :
- self.appliEficas.mesScripts[self.code]=__import__(mesScriptsNomFichier)
- except:
- pass
+ try :
+ self.appliEficas.mesScripts[self.code]=__import__(mesScriptsNomFichier)
+ except:
+ pass
try :
o=__import__(nom_cata)
- def Retrouve_Ordre_Cata_Standard_autre(self):
+ def retrouveOrdreCataStandardAutre(self):
"""
Construit une structure de donnees dans le catalogue qui permet
a EFICAS de retrouver l'ordre des mots-cles dans le texte du catalogue.
Pour chaque entite du catlogue on cree une liste de nom ordre_mc qui
contient le nom des mots cles dans le bon ordre
"""
- self.cata_ordonne_dico,self.appliEficas.liste_simp_reel=autre_analyse_cata.analyse_catalogue(self.cata)
+ self.cata_ordonne_dico,self.appliEficas.liste_simp_reel=autre_analyse_cata.analyseCatalogue(self.cata)
- def Retrouve_Ordre_Cata_Standard(self):
+ def retrouveOrdreCataStandard(self):
"""
Retrouve l'ordre des mots-cles dans le catalogue, cad :
Attention s appuie sur les commentaires
"""
nom_cata = os.path.splitext(os.path.basename(self.fic_cata))[0]
rep_cata = os.path.dirname(self.fic_cata)
- self.Commandes_Ordre_Catalogue = analyse_catalogue_initial.analyse_catalogue(self.fic_cata)
+ self.Commandes_Ordre_Catalogue = analyse_catalogue_initial.analyseCatalogue(self.fic_cata)
#print self.Commandes_Ordre_Catalogue
- def ask_choix_catalogue(self, cata_choice_list):
+ def askChoixCatalogue(self, cata_choice_list):
"""
Ouvre une fenetre de selection du catalogue dans le cas où plusieurs
ont ete definis dans Accas/editeur.ini
"""
- code = getattr(self.appliEficas.CONFIGURATION, "code", None)
+ code = getattr(self.appliEficas.maConfiguration, "code", None)
if code != None :
title=tr("Choix d une version du code ")+str(code)
else :
lab+=str(self.code)
lab+=tr(" avec le catalogue ")
if ret == QDialog.Accepted:
+ print (widgetChoix.CBChoixCata.currentIndex())
cata = cata_choice_list[widgetChoix.CBChoixCata.currentIndex()]
self.version_cata = cata.identifier
self.fic_cata = cata.cata_file_path
lab+=self.version_cata
self.appliEficas.setWindowTitle(lab)
#qApp.mainWidget().setCaption(lab)
+ widgetChoix.close()
else:
+ widgetChoix.close()
raise EficasException()
-
- def traite_clefs_documentaires(self):
+ def traiteIcones(self):
+ if self.appliEficas.maConfiguration.ficIcones==None : return
try:
- fic_doc='rep_doc_'+str(self.version_code)
- self.fic_doc=getattr(self.appliEficas.CONFIGURATION,fic_doc )
- f=open(self.fic_doc)
+ ficIcones=self.appliEficas.maConfiguration.ficIcones
+ fichierIcones = __import__(ficIcones, globals(), locals(), [], -1)
+ self.dicoIcones=fichierIcones.dicoDesIcones.dicoIcones
except:
- print ("Pas de fichier associe contenant des clefs documentaires")
- return
-
- dict_clef_docu={}
- for l in f.readlines():
- clef=l.split(':')[0]
- deb=l.find(':')+1
- docu=l[deb:-1]
- dict_clef_docu[clef]=docu
- for oper in self.cata.JdC.commandes:
- if oper.nom in dict_clef_docu :
- oper.docu=dict_clef_docu[oper.nom]
-
- def cree_dico_inverse(self):
+ print ("Pas de fichier associe contenant des liens sur les icones ")
+ self.dicoIcones={}
+
+
+
+ def creeDicoInverse(self):
self.dicoInverse={}
self.dicoMC={}
listeEtapes=self.cata[0].JdC.commandes
for e in self.cata[0].JdC.commandes:
- self.traite_entite(e)
-
- #self.dicoFrancaisAnglais={}
- #self.dicoAnglaisFrancais={}
- #for k in self.dicoInverse:
- # listefr=[]
- # for nom, obj in self.dicoInverse[k] :
- # listefr.append((tr(nom),obj))
- # self.dicoFrancaisAnglais[tr(nom)]=nom
- # self.dicoAnglaisFrancais[nom]=tr(nom)
- # self.dicoInverseFrancais[tr(k)]=listefr
- # #print tr(k),listefr
+ self.traiteEntite(e)
- def cree_dico_CasToCata(self):
+ def creeDicoCasToCata(self):
if self.appliEficas.langue=="ang" :
from dicoCasEnToCata import dicoCasEnToCata as dicoCasToCata
else :
-
- def traite_entite(self,e):
+ def traiteEntite(self,e):
boolIn=0
for (nomFils, fils) in list(e.entites.items()) :
self.dicoMC[nomFils]=fils
- self.traite_entite(fils)
+ self.traiteEntite(fils)
boolIn=1
if boolIn==0 :
liste=[]
self.dicoInverse[e.nom]=liste
self.dicoInverse[tr(e.nom)]=liste
- def cree_rubrique(self,e,dico, niveau):
+ def creeRubrique(self,e,dico, niveau):
from Accas import A_BLOC
decale=niveau*" "
#if niveau != 0 :
# if isinstance(e,A_BLOC.BLOC): print decale, e.condition
# else : print decale, e. nom
for (nom, fils) in list(e.entites.items()) :
- if list(fils.entites.items()) != [] : self.cree_rubrique(fils,dico,niveau+1)
+ if list(fils.entites.items()) != [] : self.creeRubrique(fils,dico,niveau+1)
#else : print (niveau+1)*" ", nom
nameConf='configuration_'+self.code
configuration=__import__(nameConf)
- self.CONFIGURATION = configuration.make_config(self,prefsCode.repIni)
+ self.maConfiguration = configuration.make_config(self,prefsCode.repIni)
class QWParentSSIhm(object):
def __init__(self,code,version_code):
from Extensions.i18n import tr
import types
-
-
#---------------------------#
class PopUpMenuRacine(object) :
#---------------------------#
-
def createPopUpMenu(self):
#print "createPopUpMenu"
self.ParamApres = QAction(tr('Parametre'),self.tree)
#---------------------------#
def createPopUpMenu(self):
- #print "createPopUpMenu"
+ print ("createPopUpMenu")
#self.appliEficas.salome=True
self.createActions()
self.menu = QMenu(self.tree)
if hasattr(self.appliEficas, 'mesScripts'):
if self.editor.code in self.editor.appliEficas.mesScripts :
self.dict_commandes_mesScripts=self.appliEficas.mesScripts[self.editor.code].dict_commandes
- if self.tree.currentItem().item.get_nom() in self.dict_commandes_mesScripts :
+ if self.tree.currentItem().item.getNom() in self.dict_commandes_mesScripts :
self.ajoutScript()
+ if self.appliEficas.code == 'MT' :
+ item=self
+ depth=0
+ while(item!=None) :
+ depth = depth+1
+ item = item.parent()
+ if depth != 3 : return
+ from InterfaceQT4 import composimp
+ if (isinstance(self,composimp.Node)) : return
+ label=('Deplie ce niveau')
+ self.actionDeplie=QAction(label,self.tree)
+ self.actionDeplie.triggered.connect(self.deplieCeNiveau)
+ self.menu.addAction(self.actionDeplie)
def ajoutScript(self):
from Extensions import jdc_include
if isinstance(self.item.jdc,jdc_include.JDC_INCLUDE) : return
- listeCommandes=self.dict_commandes_mesScripts[self.tree.currentItem().item.get_nom()]
+ listeCommandes=self.dict_commandes_mesScripts[self.tree.currentItem().item.getNom()]
if type(listeCommandes) != tuple: listeCommandes=(listeCommandes,)
numero=0
for commande in listeCommandes :
tip=commande[5]
self.action=QAction(label,self.tree)
self.action.setStatusTip(tip)
- if numero==4: self.action.triggered.connect(self.AppelleFonction4)
- if numero==3: self.action.triggered.connect(self.AppelleFonction3); numero=4
- if numero==2: self.action.triggered.connect(self.AppelleFonction2); numero=3
- if numero==1: self.action.triggered.connect(self.AppelleFonction1); numero=2
- if numero==0: self.action.triggered.connect(self.AppelleFonction0); numero=1
+ if numero==4: self.action.triggered.connect(self.appelleFonction4)
+ if numero==3: self.action.triggered.connect(self.appelleFonction3); numero=4
+ if numero==2: self.action.triggered.connect(self.appelleFonction2); numero=3
+ if numero==1: self.action.triggered.connect(self.appelleFonction1); numero=2
+ if numero==0: self.action.triggered.connect(self.appelleFonction0); numero=1
self.menu.addAction(self.action)
- def AppelleFonction0(self):
- self.AppelleFonction(0)
-
- def AppelleFonction1(self):
- self.AppelleFonction(1)
+ def appelleFonction0(self):
+ self.appelleFonction(0)
- def AppelleFonction2(self):
- self.AppelleFonction(2)
+ def appelleFonction1(self):
+ self.appelleFonction(1)
- def AppelleFonction3(self):
- self.AppelleFonction(3)
+ def appelleFonction2(self):
+ self.appelleFonction(2)
- def AppelleFonction4(self):
- self.AppelleFonction(4)
+ def appelleFonction3(self):
+ self.appelleFonction(3)
+ def appelleFonction4(self):
+ self.appelleFonction(4)
- def AppelleFonction(self,numero,nodeTraite=None):
+ def appelleFonction(self,numero,nodeTraite=None):
if nodeTraite==None : nodeTraite=self.tree.currentItem()
- nomCmd=nodeTraite.item.get_nom()
+ nomCmd=nodeTraite.item.getNom()
if hasattr(self.appliEficas, 'mesScripts'):
if self.editor.code in self.editor.appliEficas.mesScripts :
self.dict_commandes_mesScripts=self.appliEficas.mesScripts[self.editor.code].dict_commandes
conditionValid=commande[4]
- if (nodeTraite.item.isvalid() == 0 and conditionValid == True):
+ if (nodeTraite.item.isValid() == 0 and conditionValid == True):
QMessageBox.warning( None,
tr("item invalide"),
tr("l item doit etre valide"),)
- def createActionsQT4(self):
- self.CommApres = QAction(tr('apres'),self.tree)
- self.tree.connect(self.CommApres,SIGNAL("triggered()"),self.addCommApres)
- self.CommApres.setStatusTip(tr("Insere un commentaire apres la commande "))
- self.CommAvant = QAction(tr('avant'),self.tree)
- self.tree.connect(self.CommAvant,SIGNAL("triggered()"),self.addCommAvant)
- self.CommAvant.setStatusTip(tr("Insere un commentaire avant la commande "))
-
- self.ParamApres = QAction(tr('apres'),self.tree)
- self.tree.connect(self.ParamApres,SIGNAL("triggered()"),self.addParametersApres)
- self.ParamApres.setStatusTip(tr("Insere un parametre apres la commande "))
- self.ParamAvant = QAction(tr('avant'),self.tree)
- self.tree.connect(self.ParamAvant,SIGNAL("triggered()"),self.addParametersAvant)
- self.ParamAvant.setStatusTip(tr("Insere un parametre avant la commande "))
-
- self.Supprime = QAction(tr('Supprimer'),self.tree)
- self.tree.connect(self.Supprime,SIGNAL("triggered()"),self.supprimeNoeud)
- self.Supprime.setStatusTip(tr("supprime le mot clef "))
- self.Documentation = QAction(tr('Documentation'),self.tree)
- self.tree.connect(self.Documentation,SIGNAL("triggered()"),self.viewDoc)
def createActions(self):
self.CommApres = QAction(tr('apres'),self.tree)
def viewDoc(self):
self.node=self.tree.currentItem()
- cle_doc = self.node.item.get_docu()
+ cle_doc = self.node.item.getDocu()
if cle_doc == None :
QMessageBox.information( self.editor,tr( "Documentation Vide"), \
tr("Aucune documentation n'est associee a ce noeud"))
return
- commande = self.editor.appliEficas.CONFIGURATION.exec_acrobat
+ commande = self.editor.appliEficas.maConfiguration.exec_acrobat
try :
f=open(commande,"rb")
except :
if cle_doc.startswith('http:'):
fichier = cle_doc
else :
- fichier = os.path.abspath(os.path.join(self.editor.CONFIGURATION.path_doc,
+ fichier = os.path.abspath(os.path.join(self.editor.maConfiguration.path_doc,
cle_doc))
try :
f=open(fichier,"rb")
item= self.tree.currentItem()
item.addComment(False)
+ def deplieCeNiveau(self):
+ item= self.tree.currentItem()
+ item.deplieCeNiveau()
+
#--------------------------------------------#
class PopUpMenuNodePartiel (PopUpMenuNodeMinimal):
#---------------------------------------------#
def createPopUpMenu(self):
PopUpMenuNodePartiel.createPopUpMenu(self)
self.Commente = QAction(tr('ce noeud'),self.tree)
- self.Commente.triggered.connect(self.Commenter)
+ self.Commente.triggered.connect(self.commenter)
self.Commente.setStatusTip(tr("commente le noeud "))
self.commentMenu.addAction(self.Commente)
self.menu.removeAction(self.Supprime)
self.menu.addAction(self.Supprime)
- def Commenter(self):
+ def commenter(self):
item= self.tree.currentItem()
item.commentIt()
index=self.myQtab.currentIndex()
if index in self.dict_editors:
editor=self.dict_editors[index]
- self.appliEficas.CONFIGURATION=editor.CONFIGURATION
- self.appliEficas.code=editor.CONFIGURATION.code
+ self.appliEficas.maConfiguration=editor.maConfiguration
+ self.appliEficas.code=editor.maConfiguration.code
self.appliEficas.setWindowTitle(editor.titre)
self.appliEficas.construitMenu()
fichier = QFileDialog.getOpenFileName(self.appliEficas,
tr('Ouvrir Fichier'),
- self.appliEficas.CONFIGURATION.savedir,
+ self.appliEficas.maConfiguration.savedir,
extensions)
fichier=fichier[0]
fichier = os.path.abspath(six.text_type(fichier))
ulfile = os.path.abspath(six.text_type(fichier))
- self.appliEficas.CONFIGURATION.savedir=os.path.split(ulfile)[0]
+ self.appliEficas.maConfiguration.savedir=os.path.split(ulfile)[0]
self.appliEficas.addToRecentList(fichier)
maPage=self.getEditor( fichier,units=units)
if maPage: result = maPage
editor=self.dict_editors[index]
editor.handleSupprimer()
+ def handleAjoutEtape(self,nomEtape):
+ index=self.myQtab.currentIndex()
+ if index < 0 : return
+ editor=self.dict_editors[index]
+ editor.handleAjoutEtape(nomEtape)
+
+
def newEditor(self,include=0):
if self.appliEficas.demande==True :
self.appliEficas.definitCode(None,None)
if index < 0 : return
self.dict_editors[index].viewJdcRegles()
- def handlegestionParam(self):
+ def handleGestionParam(self):
index=self.myQtab.currentIndex()
if index < 0 :
QMessageBox.warning( self.appliEficas,tr(u"Creation Parametre indisponible"),tr(u"les parametres sont lies a un jeu de donnees"))
indexEditor=0
for indexEditor in self.dict_editors :
editor=self.dict_editors[indexEditor]
- if self.samepath(fichier, editor.getFileName()):
+ if self.samePath(fichier, editor.getFileName()):
msgBox = QMessageBox()
msgBox.setWindowTitle(tr("Fichier"))
msgBox.setText(tr("Le fichier <b>%s</b> est deja ouvert", str(fichier)))
else :
from .editor import JDCEditor
editor = JDCEditor(self.appliEficas,fichier, jdc, self.myQtab,units=units,vm = self,include=include)
-
if double != None :
self.doubles[editor]=double
if editor.jdc: # le fichier est bien un jdc
except :
return ""
- def samepath(self,f1, f2):
+ def samePath(self,f1, f2):
"""
compare two paths.
"""
else:
self.parent = CONTEXT.get_current_step()
if self.parent:
- self.jdc = self.parent.get_jdc_root()
+ self.jdc = self.parent.getJdcRoot()
else:
self.jdc = None
enregistrements necessaires
"""
if self.parent:
- self.jdc = self.parent.get_jdc_root()
+ self.jdc = self.parent.getJdcRoot()
self.id = self.parent.register(self)
self.niveau = None
else:
self.definition.op_init(*(
self, self.parent.g_context))
else:
- sd = self.get_sd_prod()
+ sd = self.getSdProd()
# On n'utilise pas self.definition.op_init car self.parent
# n'existe pas
if sd != None and self.reuse == None:
"""
return
- def get_sd_prod(self):
+ def getSdProd(self):
"""
Retourne le concept resultat de l'etape
Deux cas :
et on le retourne
"""
if type(self.definition.sd_prod) == types.FunctionType:
- d = self.cree_dict_valeurs(self.mc_liste)
+ d = self.creeDictValeurs(self.mc_liste)
try:
sd_prod = self.definition.sd_prod(*(), **d)
except EOFError:
Developpeur : La fonction "sd_prod" retourne un type invalide.""")
return self.sd
- def get_type_produit(self):
+ def getType_produit(self):
try:
- return self.get_type_produit_brut()
+ return self.getType_produit_brut()
except:
return None
- def get_type_produit_brut(self):
+ def getType_produit_brut(self):
"""
Retourne le type du concept resultat de l'etape
Deux cas :
et on retourne son resultat
"""
if type(self.definition.sd_prod) == types.FunctionType:
- d = self.cree_dict_valeurs(self.mc_liste)
+ d = self.creeDictValeurs(self.mc_liste)
sd_prod = self.definition.sd_prod(*(), **d)
else:
sd_prod = self.definition.sd_prod
def __del__(self):
pass
- def get_created_sd(self):
+ def getCreated_sd(self):
"""Retourne la liste des sd reellement produites par l'etape.
Si reuse est present, `self.sd` a ete creee avant, donc n'est pas dans
cette liste."""
return [self.sd, ]
return []
- def isactif(self):
+ def isActif(self):
"""
Indique si l'etape est active (1) ou inactive (0)
"""
"""
return 0
- def get_file(self, unite=None, fic_origine='', fname=None):
+ def getFile(self, unite=None, fic_origine='', fname=None):
"""
Retourne le nom du fichier correspondant a un numero d'unite
logique (entier) ainsi que le source contenu dans le fichier
"""
if self.jdc:
- return self.jdc.get_file(unite=unite, fic_origine=fic_origine, fname=fname)
+ return self.jdc.getFile(unite=unite, fic_origine=fic_origine, fname=fname)
else:
if unite != None:
if os.path.exists("fort." + str(unite)):
"""
visitor.visitETAPE(self)
- def update_context(self, d):
+ def updateContext(self, d):
"""
Cette methode doit updater le contexte fournit par
l'appelant en argument (d) en fonction de sa definition
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
for mocle in self.mc_liste:
mocle.reparent(self)
else:
self.parent = CONTEXT.get_current_step()
if self.parent:
- self.jdc = self.parent.get_jdc_root()
+ self.jdc = self.parent.getJdcRoot()
else:
self.jdc = None
"""
try:
if self.appli != None:
- self.appli.affiche_infos(
+ self.appli.afficheInfos(
'Compilation du fichier de commandes en cours ...')
# Python 2.7 compile function does not accept unicode filename, so we encode it
# with the current locale encoding in order to have a correct
self.sds_dict[sdnom] = sd
if self.appli != None:
- self.appli.affiche_infos(
+ self.appli.afficheInfos(
'Interpretation du fichier de commandes en cours ...')
# On sauve le contexte pour garder la memoire des constantes
# En mode edition (EFICAS) ou lors des verifications le contexte
CONTEXT.unset_current_step()
if self.appli != None:
- self.appli.affiche_infos('')
+ self.appli.afficheInfos('')
except InterruptParsingError:
# interrupt the command file parsing used by FIN to ignore the end
etape.
Dans le cas du JDC, le deuxième cas ne peut pas se produire.
"""
- sd = etape.get_sd_prod()
+ sd = etape.getSdProd()
if sd != None and (etape.definition.reentrant == 'n' or etape.reuse is None):
# ATTENTION : On ne nomme la SD que dans le cas de non reutilisation
# d un concept. Commande non reentrante ou reuse absent.
"""
return self.o_register(sd)
- def delete_concept_after_etape(self, etape, sd):
+ def deleteConceptAfterEtape(self, etape, sd):
"""
Met a jour les etapes du JDC qui sont après etape suite a
la disparition du concept sd
e.jdc = jdc
del self.index_etapes[e]
- def get_file(self, unite=None, fic_origine='', fname=None):
+ def getFile(self, unite=None, fic_origine='', fname=None):
"""
Retourne le nom du fichier correspondant a un numero d'unite
logique (entier) ainsi que le source contenu dans le fichier
if self.appli:
# Si le JDC est relie a une application maitre, on delègue la
# recherche
- return self.appli.get_file(unite, fic_origine)
+ return self.appli.getFile(unite, fic_origine)
else:
if unite != None:
if os.path.exists("fort." + str(unite)):
En PAR_LOT='NON', il n'y a pas d'ambiguite.
d'analyse et juste avant la phase d'execution.
`user_value` : permet de stocker la valeur choisie par l'utilisateur
- pour l'interroger plus tard (par exemple dans `get_contexte_avant`).
+ pour l'interroger plus tard (par exemple dans `getContexte_avant`).
"""
if user_value:
self.par_lot_user = par_lot
console = None
CONTEXT.unset_current_step()
- def get_contexte_avant(self, etape):
+ def getContexte_avant(self, etape):
"""
Retourne le dictionnaire des concepts connus avant etape
On tient compte des commandes qui modifient le contexte
if etape is None:
return d
# retirer les sd produites par 'etape'
- sd_names = [sd.nom for sd in etape.get_created_sd()]
+ sd_names = [sd.nom for sd in etape.getCreated_sd()]
for nom in sd_names:
try:
del d[nom]
for e in liste_etapes:
if e is etape:
break
- if e.isactif():
- e.update_context(d)
+ if e.isActif():
+ e.updateContext(d)
self.index_etape_courante = index_etape
return d
d.update(self.g_context)
return d
- def get_contexte_courant(self, etape_courante=None):
+ def getContexte_courant(self, etape_courante=None):
"""
Retourne le contexte tel qu'il est (ou 'sera' si on est en phase
de construction) au moment de l'execution de l'etape courante.
"""
if etape_courante is None:
etape_courante = CONTEXT.get_current_step()
- return self.get_contexte_avant(etape_courante)
+ return self.getContexte_avant(etape_courante)
def get_concept(self, nomsd):
"""
Methode pour recuperer un concept a partir de son nom
"""
- co = self.get_contexte_courant().get(nomsd.strip(), None)
+ co = self.getContexte_courant().get(nomsd.strip(), None)
if not isinstance(co, ASSD):
co = None
return co
self.definition.op_init(*(
self, self.parent.g_context))
else:
- sd = self.get_sd_prod()
+ sd = self.getSdProd()
if sd != None and self.reuse == None:
# On ne nomme le concept que dans le cas de non reutilisation
# d un concept
self.Execute()
return sd
- def get_sd_prod(self):
+ def getSdProd(self):
"""
Retourne le concept resultat d'une macro etape
La difference avec une etape ou une proc-etape tient a ce que
self.typret = None
if type(self.definition.sd_prod) == types.FunctionType:
- d = self.cree_dict_valeurs(self.mc_liste)
+ d = self.creeDictValeurs(self.mc_liste)
try:
# la sd_prod d'une macro a l'objet macro_etape lui meme en premier argument
# Comme sd_prod peut invoquer la methode type_sdprod qui ajoute
Developpeur : La fonction "sd_prod" retourne un type invalide.""")
return self.sd
- def get_type_produit(self, force=0):
+ def getType_produit(self, force=0):
try:
- return self.get_type_produit_brut(force)
+ return self.getType_produit_brut(force)
except:
# traceback.print_exc()
return None
- def get_type_produit_brut(self, force=0):
+ def getType_produit_brut(self, force=0):
"""
Retourne le type du concept resultat de l'etape et eventuellement type
les concepts produits "a droite" du signe egal (en entree)
return self.typret
if type(self.definition.sd_prod) == types.FunctionType:
- d = self.cree_dict_valeurs(self.mc_liste)
+ d = self.creeDictValeurs(self.mc_liste)
# Comme sd_prod peut invoquer la methode type_sdprod qui ajoute
# les concepts produits dans self.sdprods, il faut le mettre a zero
self.sdprods = []
sd_prod = self.definition.sd_prod
return sd_prod
- def get_contexte_avant(self, etape):
+ def getContexte_avant(self, etape):
"""
Retourne le dictionnaire des concepts connus avant etape
pour les commandes internes a la macro
if etape is None:
return d
# retirer les sd produites par 'etape'
- sd_names = [sd.nom for sd in etape.get_created_sd()]
+ sd_names = [sd.nom for sd in etape.getCreated_sd()]
for nom in sd_names:
try:
del d[nom]
if nomsd in self.Outputs:
# Il s'agit d'un concept de sortie de la macro. Il ne faut pas le creer
# Il faut quand meme appeler la fonction sd_prod si elle existe.
- # get_type_produit le fait et donne le type attendu par la commande
+ # getType_produit le fait et donne le type attendu par la commande
# pour verification ulterieure.
- sdprod = etape.get_type_produit_brut()
+ sdprod = etape.getType_produit_brut()
sd = self.Outputs[nomsd]
# On verifie que le type du concept existant sd.__class__ est un sur type de celui attendu
# Cette règle est normalement coherente avec les règles de
self.g_context[sd.nom] = sd
elif etape.definition.reentrant != 'n' and etape.reuse != None:
# On est dans le cas d'une commande avec reutilisation d'un concept existant
- # get_sd_prod fait le necessaire : verifications, associations, etc. mais ne cree
+ # getSdProd fait le necessaire : verifications, associations, etc. mais ne cree
# pas un nouveau concept. Il retourne le concept reutilise
- sd = etape.get_sd_prod()
+ sd = etape.getSdProd()
# Dans le cas d'un concept nomme automatiquement : _xxx, __xxx,
# On force le nom stocke dans l'attribut sdnom de l'objet etape : on lui donne le nom
# du concept reutilise (sd ou etape.reuse c'est pareil)
etape.sdnom = sd.nom
else:
# On est dans le cas de la creation d'un nouveau concept
- sd = etape.get_sd_prod()
+ sd = etape.getSdProd()
if sd != None:
self.NommerSdprod(sd, nomsd)
return sd
# le concept dans son contexte. On ne traite plus que le nommage (restrict="oui")
self.parent.NommerSdprod(sd, sdnom, restrict='oui')
- def delete_concept_after_etape(self, etape, sd):
+ def deleteConceptAfterEtape(self, etape, sd):
"""
Met a jour les etapes de la MACRO qui sont après etape suite a
la disparition du concept sd
# Dans d'autres conditions, il faudrait surcharger cette methode.
return
- def get_created_sd(self):
+ def getCreated_sd(self):
"""Retourne la liste des sd reellement produites par l'etape.
Si reuse est present, `self.sd` a ete creee avant, donc n'est pas dans
cette liste."""
"""
visitor.visitMACRO_ETAPE(self)
- def update_context(self, d):
+ def updateContext(self, d):
"""
Met a jour le contexte contenu dans le dictionnaire d
Une MACRO_ETAPE peut ajouter plusieurs concepts dans le contexte
fname = 'fort.%s' % unite
if not fname:
return
- f, text = self.get_file(fic_origine=self.parent.nom, fname=fname)
+ f, text = self.getFile(fic_origine=self.parent.nom, fname=fname)
self.fichier_init = f
if f == None:
return
# Le contexte global est forme par concatenation du contexte
# du parent de self et de celui de l'etape elle meme (self)
# Pour les concepts, cela ne doit rien changer. Mais pour les constantes,
- # les valeurs de get_contexte_avant sont moins recentes que dans
+ # les valeurs de getContexte_avant sont moins recentes que dans
# get_global_contexte. On prend donc la precaution de ne pas ecraser
# ce qui y est deja.
d = self.parent.get_global_contexte()
d.update(self.g_context)
- d.update([(k, v) for k, v in list(self.parent.get_contexte_avant(self).items())
+ d.update([(k, v) for k, v in list(self.parent.getContexte_avant(self).items())
if d.get(k) is None])
return d
- def get_contexte_courant(self, etape_fille_du_jdc=None):
+ def getContexte_courant(self, etape_fille_du_jdc=None):
"""
Retourne le contexte tel qu'il est au moment de l'execution de
l'etape courante.
"""
ctx = {}
# update car par ricochet on modifierait jdc.current_context
- ctx.update(self.parent.get_contexte_courant(self))
+ ctx.update(self.parent.getContexte_courant(self))
# on peut mettre None car toujours en PAR_LOT='NON', donc la dernière
- ctx.update(self.get_contexte_avant(None))
+ ctx.update(self.getContexte_avant(None))
return ctx
def get_concept(self, nomsd):
Methode pour recuperer un concept a partir de son nom
dans le contexte du jdc connu avant l'execution de la macro courante.
"""
- # chercher dans self.get_contexte_avant, puis si non trouve
+ # chercher dans self.getContexte_avant, puis si non trouve
# self.parent.get_concept est peut-etre plus performant
- co = self.get_contexte_courant().get(nomsd.strip(), None)
+ co = self.getContexte_courant().get(nomsd.strip(), None)
if not isinstance(co, ASSD):
co = None
return co
self.etape = None
self.mc_liste = self.build_mc()
- def get_valeur(self):
+ def getValeur(self):
"""
Retourne la "valeur" de l'objet bloc. Il s'agit d'un dictionnaire dont
les clés seront les noms des objets de self.mc_liste et les valeurs
les valeurs des objets de self.mc_liste obtenues par application de
- la méthode get_valeur.
+ la méthode getValeur.
Dans le cas particulier d'un objet bloc les éléments du dictionnaire
- obtenu par appel de la méthode get_valeur sont intégrés au niveau
+ obtenu par appel de la méthode getValeur sont intégrés au niveau
supérieur.
"""
# Si mocle est un BLOC, on inclut ses items dans le dictionnaire
# représentatif de la valeur de self. Les mots-clés fils de blocs sont
# donc remontés au niveau supérieur.
- dico.update(mocle.get_valeur())
+ dico.update(mocle.getValeur())
else:
- dico[mocle.nom] = mocle.get_valeur()
+ dico[mocle.nom] = mocle.getValeur()
# On rajoute tous les autres mots-clés locaux possibles avec la valeur
# par défaut ou None
# mais qui sont malgré tout des descendants de l'objet courant
# (petits-fils, ...)
args = self.valeur
- if args == None:
- args = {}
+ if args == None: args = {}
mc_liste = []
# On recopie le dictionnaire des arguments pour protéger l'original des
args = bloc.reste_val
# On ne recalcule pas le contexte car on ne tient pas compte des blocs
# pour évaluer les conditions de présence des blocs
- # dico_valeurs = self.cree_dict_valeurs(mc_liste)
+ # dico_valeurs = self.creeDictValeurs(mc_liste)
# On conserve les arguments superflus dans l'attribut reste_val
self.reste_val = args
Seulement pour IHM graphique
"""
if self.jdc and self.jdc.cata_ordonne_dico != None:
- liste_noms_mc_ordonnee = self.get_liste_mc_ordonnee_brute(
- self.get_genealogie(), self.jdc.cata_ordonne_dico)
+ liste_noms_mc_ordonnee = self.getListeMcOrdonnee_brute(
+ self.getGenealogie(), self.jdc.cata_ordonne_dico)
return self.ordonne_liste_mc(mc_liste, liste_noms_mc_ordonnee)
else:
return mc_liste
- def cree_dict_valeurs(self, liste=[], condition=0):
+ def creeDictValeurs(self, liste=[], condition=0):
"""
Cette méthode crée un contexte (sous la forme d'un dictionnaire)
à partir des valeurs des mots clés contenus dans l'argument liste.
for v in liste:
if v.isBLOC():
# Si v est un BLOC, on inclut ses items dans le dictionnaire
- # représentatif du contexte. Les blocs sont retournés par get_valeur
+ # représentatif du contexte. Les blocs sont retournés par getValeur
# sous la forme d'un dictionnaire : les mots-clés fils de blocs sont
# donc remontés au niveau du contexte.
if not condition:
- dadd = v.get_valeur()
+ dadd = v.getValeur()
assert intersection_vide(dico, dadd)
dico.update(dadd)
else:
assert not v.nom in dico, "deja vu : %s" % v.nom
- dico[v.nom] = v.get_valeur()
+ dico[v.nom] = v.getValeur()
# On rajoute tous les autres mots-clés locaux possibles avec la valeur
# par défaut ou None
return dico
def cree_dict_toutes_valeurs(self):
- """Semblable à `cree_dict_valeurs(liste=self.mc_liste)` en supprimant les
+ """Semblable à `creeDictValeurs(liste=self.mc_liste)` en supprimant les
valeurs None."""
- dico = self.cree_dict_valeurs(self.mc_liste, condition=0)
+ dico = self.creeDictValeurs(self.mc_liste, condition=0)
dico = dict([(k, v) for k, v in list(dico.items()) if v is not None])
return dico
des conditions de présence de blocs. Si une commande a un concept
produit réutilisé, on ajoute la clé 'reuse'
"""
- dico = self.cree_dict_valeurs(liste, condition=1)
+ dico = self.creeDictValeurs(liste, condition=1)
# On ajoute la cle "reuse" pour les MCCOMPO qui ont un attribut reuse. A destination
# uniquement des commandes. Ne devrait pas etre dans cette classe mais
# dans une classe dérivée
if etape:
dict_mc_globaux_fac = self.recherche_mc_globaux_facultatifs()
for k, v in list(etape.mc_globaux.items()):
- dict_mc_globaux_fac[k] = v.get_valeur()
+ dict_mc_globaux_fac[k] = v.getValeur()
if self.jdc:
for k, v in list(self.jdc.mc_globaux.items()):
- dict_mc_globaux_fac[k] = v.get_valeur()
+ dict_mc_globaux_fac[k] = v.getValeur()
return dict_mc_globaux_fac
else:
return {}
if v.statut == 'o':
continue
obj = v(val=None, nom=k, parent=etape)
- dico[k] = obj.get_valeur()
+ dico[k] = obj.getValeur()
return dico
def supprime(self):
dans un BLOC fils de self
"""
# on cherche dans les mots cles presents, le mot cle de nom key
- # s'il est là on retourne sa valeur (méthode get_val)
+ # s'il est là on retourne sa valeur (méthode getVal)
for child in self.mc_liste:
if child.nom == key:
- return child.get_valeur()
+ return child.getValeur()
# Si on n a pas trouve de mot cle present on retourne le defaut
# eventuel pour les mots cles accessibles dans la definition
# a ce niveau
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 = parent.etape
for mocle in self.mc_liste:
mocle.reparent(self)
else:
return val
- def get_valeur(self):
+ def getValeur(self):
"""
Retourne la "valeur" d'un mot-clé facteur qui est l'objet lui-meme.
Cette valeur est utilisée lors de la création d'un contexte
"""
return self
- def get_val(self):
+ def getVal(self):
"""
Une autre méthode qui retourne une "autre" valeur du mot clé facteur.
Elle est utilisée par la méthode get_mocle
self.niveau = None
self.etape = None
- def get_valeur(self):
+ def getValeur(self):
"""
Retourne la "valeur" d'un objet MCList. Sert à construire
un contexte d'évaluation pour une expression Python.
"""
return self
- def get_val(self):
+ def getVal(self):
"""
Une autre méthode qui retourne une "autre" valeur d'une MCList
Elle est utilisée par la méthode get_mocle
"""
dresu = []
for mcf in self:
- dico = mcf.cree_dict_valeurs(mcf.mc_liste)
+ dico = mcf.creeDictValeurs(mcf.mc_liste)
for i in list(dico.keys()):
if dico[i] == None:
del dico[i]
val = self.convProto.convert(val)
return val
- def get_valeur(self):
+ def getValeur(self):
"""
Retourne la "valeur" d'un mot-clé simple.
Cette valeur est utilisée lors de la création d'un contexte
v = (v, )
return v
- def get_val(self):
+ def getVal(self):
"""
Une autre méthode qui retourne une "autre" valeur du mot clé simple.
Elle est utilisée par la méthode get_mocle
self.jdc = None
self.niveau = None
- def get_val(self):
+ def getVal(self):
"""
Retourne la valeur de l'objet. Cette méthode fournit
une valeur par defaut. Elle doit etre dérivée pour chaque
"""
return 0
- def get_jdc_root(self):
+ def getJdcRoot(self):
"""
Cette méthode doit retourner l'objet racine c'est à dire celui qui
n'a pas de parent
"""
if self.parent:
- return self.parent.get_jdc_root()
+ return self.parent.getJdcRoot()
else:
return self
# self.niveau = None
# self.etape = None
- def isvalid(self, cr='non'):
+ def isValid(self, cr='non'):
return 0
def report(self):
Elle doit retourner le concept produit qui pour une PROC est toujours None
En cas d'erreur, elle leve une exception : AsException ou EOFError
"""
- if not self.isactif():
+ if not self.isActif():
return
try:
if self.parent:
"""
visitor.visitPROC_ETAPE(self)
- def update_context(self, d):
+ def updateContext(self, d):
"""
Met à jour le contexte de l'appelant passé en argument (d)
Une PROC_ETAPE n ajoute pas directement de concept dans le contexte
"""
return self.info()
- def info_erreur_item(self):
+ def infoErreurItem(self):
"""
Cette méthode permet d'avoir un message d'erreur pour un item
dans une liste dans le cas ou le validateur fait des vérifications
"""
return " "
- def info_erreur_liste(self):
+ def infoErreurListe(self):
"""
Cette méthode a un comportement complémentaire de celui de
- info_erreur_item. Elle retourne un message d'erreur lié uniquement
+ infoErreurItem. Elle retourne un message d'erreur lié uniquement
aux vérifications sur la liste elle meme et pas sur ses items.
Dans le cas où le validateur ne fait pas de vérification sur des
listes, elle retourne une chaine vide
La methode verif du validateur effectue une validation complete de
la valeur. valeur peut etre un scalaire ou une liste. Le validateur
doit traiter les 2 aspects s'il accepte des listes (dans ce cas la
- methode is_list doit retourner 1).
+ methode isList doit retourner 1).
La methode valid_item sert pour effectuer des validations partielles
de liste. Elle doit uniquement verifier la validite d'un item de
liste mais pas les caracteristiques de la liste.
"""
return 0
- def valide_liste_partielle(self, liste_courante):
+ def valideListePartielle(self, liste_courante):
"""
Cette methode retourne un entier qui indique si liste_courante est partiellement valide (valeur 1)
ou invalide (valeur 0). La validation partielle concerne les listes en cours de construction : on
"""
return 1
- def is_list(self):
+ def isList(self):
"""
Cette méthode retourne un entier qui indique si le validateur
permet les listes (valeur 1) ou ne les permet pas (valeur 0).
"""
return 0
- def has_into(self):
+ def hasInto(self):
"""
Cette méthode retourne un entier qui indique si le validateur
propose une liste de choix (valeur 1) ou n'en propose pas.
des listes.
"""
- def is_list(self):
+ def isList(self):
return 1
def get_into(self, liste_courante=None, into_courant=None):
tr("%s ne contient pas les elements obligatoires : %s ") % (valeur, elem))
return valeur
- def has_into(self):
+ def hasInto(self):
return 1
def verif(self, valeur):
return 0
return 1
- def info_erreur_item(self):
+ def infoErreurItem(self):
return tr("La valeur n'est pas dans la liste des choix possibles")
raise ValError(tr("%s ne contient pas les elements devant etre presents ensemble: %s ") %( valeur, elem))
return valeur
- def has_into(self):
+ def hasInto(self):
return 1
def verif(self, valeur):
if ( compte != len( list(self.elem) ) ): return 0
return 1
- def info_erreur_item(self):
+ def infoErreurItem(self):
return tr("La valeur n'est pas dans la liste des choix possibles")
raise ValError(tr("%s n'est pas autorise : %s ")% (v, elem))
return valeur
- def has_into(self):
+ def hasInto(self):
return 1
def verif(self, valeur):
if val in liste: return 0
return 1
- def info_erreur_item(self):
+ def infoErreurItem(self):
return tr("La valeur n'est pas dans la liste des choix possibles")
def info(self):
return tr("Pas de doublon dans la liste")
- def info_erreur_liste(self):
+ def infoErreurListe(self):
return tr("Les doublons ne sont pas permis")
def default(self, valeur):
def info(self):
return (tr("longueur de la chaine entre %s et %s") %( self.low, self.high))
- def info_erreur_item(self):
+ def infoErreurItem(self):
return tr("Longueur de la chaine incorrecte")
def convert(self, valeur):
def info(self):
return tr("regarde si c'est une chaine")
- def info_erreur_item(self):
+ def infoErreurItem(self):
return tr("Ce n'est pas une chaine")
def convert(self, valeur):
def info(self):
return ("liste %s" % self.ord)
- def info_erreur_liste(self):
+ def infoErreurListe(self):
return (tr("La liste doit etre en ordre %s") % self.ord)
def convert(self, valeur):
pass
raise ValError(tr("%s n'est pas du bon type")% repr(valeur))
- def info_erreur_item(self):
+ def infoErreurItem(self):
l = []
for v in self.validators:
- err = v.info_erreur_item()
+ err = v.infoErreurItem()
if err != " ":
l.append(err)
chaine = " \n ou ".join(l)
return chaine
- def info_erreur_liste(self):
+ def infoErreurListe(self):
l = []
for v in self.validators:
- err = v.info_erreur_liste()
+ err = v.infoErreurListe()
if err != " ":
l.append(err)
chaine = " \n ou ".join(l)
return chaine
- def is_list(self):
+ def isList(self):
"""
Si plusieurs validateurs sont reliés par un OU
il suffit qu'un seul des validateurs attende une liste
pour qu'on considère que leur union attend une liste.
"""
for validator in self.validators:
- v = validator.is_list()
+ v = validator.isList()
if v:
return 1
return 0
self.cata_info = ""
return 1
- def has_into(self):
+ def hasInto(self):
"""
Dans le cas ou plusieurs validateurs sont reliés par un OU
il faut que tous les validateurs proposent un choix pour
En revanche, Enum(1,2,3) OU Enum(4,5,6) propose un choix (1,2,3,4,5,6)
"""
for validator in self.validators:
- v = validator.has_into()
+ v = validator.hasInto()
if not v:
return 0
return 1
validator_into.extend(v_into)
return validator_into
- def valide_liste_partielle(self, liste_courante=None):
+ def valideListePartielle(self, liste_courante=None):
"""
Méthode de validation de liste partielle pour le validateur Or.
Si un des validateurs gérés par le validateur Or considère la
liste comme valide, le validateur Or la considère comme valide.
"""
for validator in self.validators:
- v = validator.valide_liste_partielle(liste_courante)
+ v = validator.valideListePartielle(liste_courante)
if v:
return 1
return 0
valeur = validator.convert(valeur)
return valeur
- def info_erreur_item(self):
+ def infoErreurItem(self):
chaine = ""
a = 1
for v in self.validators:
- if v.info_erreur_item() != " ":
+ if v.infoErreurItem() != " ":
if a == 1:
- chaine = v.info_erreur_item()
+ chaine = v.infoErreurItem()
a = 0
else:
- chaine = chaine + " \n et " + v.info_erreur_item()
+ chaine = chaine + " \n et " + v.infoErreurItem()
return chaine
- def info_erreur_liste(self):
+ def infoErreurListe(self):
chaine=""
a = 1
for v in self.validators:
- if v.info_erreur_liste() != " ":
+ if v.infoErreurListe() != " ":
if a == 1:
- chaine = v.info_erreur_liste()
+ chaine = v.infoErreurListe()
a = 0
else:
- chaine = chaine + " \n et " + v.info_erreur_liste()
+ chaine = chaine + " \n et " + v.infoErreurListe()
return chaine
def verif(self, valeur):
self.cata_info = ""
return 1
- def valide_liste_partielle(self, liste_courante=None):
+ def valideListePartielle(self, liste_courante=None):
"""
Méthode de validation de liste partielle pour le validateur And.
Tous les validateurs gérés par le validateur And doivent considérer
comme valide.
"""
for validator in self.validators:
- v = validator.valide_liste_partielle(liste_courante)
+ v = validator.valideListePartielle(liste_courante)
if not v:
return 0
return 1
- def is_list(self):
+ def isList(self):
"""
Si plusieurs validateurs sont reliés par un ET
il faut que tous les validateurs attendent une liste
Range(2,5) ET Pair attend une liste
"""
for validator in self.validators:
- v = validator.is_list()
+ v = validator.isList()
if v == 0:
return 0
return 1
- def has_into(self):
+ def hasInto(self):
"""
Dans le cas ou plusieurs validateurs sont reliés par un ET
il suffit qu'un seul validateur propose un choix pour
En revanche, entier pair ET superieur à 10 ne propose pas de choix
"""
for validator in self.validators:
- v = validator.has_into()
+ v = validator.hasInto()
if v:
return 1
return 0
def verif_item(self, valeur):
return valeur > self.low and valeur < self.high
- def info_erreur_item(self):
+ def infoErreurItem(self):
return (tr("la valeur %s doit etre comprise entre %s et %s") % (valeur, self.low, self.high))
def info(self):
return (tr("longueur de liste comprise entre %s et %s") %(self.min, self.max))
- def info_erreur_liste(self):
+ def infoErreurListe(self):
return (tr("Le cardinal de la liste doit etre compris entre %s et %s") % (self.min, self.max))
- def is_list(self):
+ def isList(self):
return self.max == '**' or self.max > 1
def get_into(self, liste_courante=None, into_courant=None):
return 0
return 1
- def valide_liste_partielle(self, liste_courante=None):
+ def valideListePartielle(self, liste_courante=None):
validite = 1
if liste_courante != None:
if len(liste_courante) > self.max:
def info(self):
return _(u"valeur paire")
- def info_erreur_item(self):
+ def infoErreurItem(self):
return tr("La valeur saisie doit etre paire")
def convert(self, valeur):
return 0
return 1
- def has_into(self):
+ def hasInto(self):
return 1
def get_into(self, liste_courante=None, into_courant=None):
liste_choix.append(e)
return liste_choix
- def info_erreur_item(self):
+ def infoErreurItem(self):
return tr("La valeur n'est pas dans la liste des choix possibles")
def info(self):
return self.function.info
- def info_erreur_item(self):
+ def infoErreurItem(self):
return self.function.info
def verif(self, valeur):
self.cata_info = ""
def info(self):
- return tr(": verifie les types dans un tuple")
+ return tr(": verifie les \ntypes dans un tuple")
- def info_erreur_liste(self):
+ def infoErreurListe(self):
return tr("Les types entres ne sont pas permis")
def default(self, valeur):
return valeur
- def is_list(self):
+ def isList(self):
return 1
def convert_item(self, valeur):
self.listeDesFreres = ()
self.fonctions = ('verifie_liste', 'set_MCSimp')
- def is_list(self):
+ def isList(self):
return 1
def verifie_liste(self, liste):
k = k - 1
# on met la liste à jour
parent.forceRecalcul = self.niveauVerif
- self.listeDesFreres = parent.liste_mc_presents()
+ self.listeDesFreres = parent.listeMcPresents()
def convert_item(self, valeur):
if valeur in self.listeDesFreres:
def info(self):
return tr('Une chaîne correspondant au motif ') + str(self.pattern) + tr(" est attendue")
- def info_erreur_item(self):
+ def infoErreurItem(self):
return tr('Une chaîne correspondant au motif ') + str(self.pattern) + tr(" est attendue")
def verif_item(self, valeur):
def info(self):
return ('Un nom de fichier se terminant par ".%s" est attendu.' % self.ext)
- def info_erreur_item(self):
+ def infoErreurItem(self):
return ('Un nom de fichier se terminant par ".%s" est attendu.' % self.ext)
class CreeMotClef(object):
if parent.get_child(self.MotClef) == None : longueur=0
else : longueur=len(parent.get_child(self.MotClef))
- pos=parent.get_index_child(self.MCSimp.nom)+1
+ pos=parent.getIndex_child(self.MCSimp.nom)+1
while longueur < valeur :
parent.inhibeValidator=1
- parent.addentite(self.MotClef,pos)
+ parent.addEntite(self.MotClef,pos)
pos=pos+1
parent.inhibeValidator=0
longueur=len(parent.get_child(self.MotClef))
parent.inhibeValide=1
parentObj=parent.get_child(self.MotClef)
obj=parent.get_child(self.MotClef)[-1]
- parentObj.suppentite(obj)
+ parentObj.suppEntite(obj)
longueur=len(parent.get_child(self.MotClef))
parent.inhibeValide=0
return lval
return isinstance(obj, (str, six.text_type))
-def is_list(obj):
+def isList(obj):
return type(obj) is list
def is_sequence(obj):
"""a sequence (allow iteration, not a string) ?"""
- return is_list(obj) or is_tuple(obj) or is_array(obj)
+ return isList(obj) or is_tuple(obj) or is_array(obj)
def is_assd(obj):
# -*- coding: utf-8 -*-\r
-# CONFIGURATION MANAGEMENT OF EDF VERSION\r
+# maConfiguration MANAGEMENT OF EDF VERSION\r
# ======================================================================\r
# COPYRIGHT (C) 1991 - 2002 EDF R&D WWW.CODE-ASTER.ORG\r
# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY\r
if premier == 1 and chercheLigne[fin] == ',': fin = fin + 1 # on supprime la ,
finLigne = chercheLigne[fin:]
MaLigne_tmp=debLigne+finLigne
- # Traitement ligne commancant par ,
+ # traitement ligne commancant par ,
if len(MaLigne_tmp.strip()) > 0 :
if MaLigne_tmp.strip()[0]==',' :
MaLigne=MaLigne_tmp.strip()[1:]
boolChange=0
if debug :
if ensemble != regles.SansRegle :
- logging.info("Traitement de %s renomme en %s sous conditions", command, new_name)
+ logging.info("traitement de %s renomme en %s sous conditions", command, new_name)
else :
- logging.info("Traitement de %s renomme en %s ", command, new_name)
+ logging.info("traitement de %s renomme en %s ", command, new_name)
for c in jdc.root.childNodes:
if c.name != command:continue
if ensemble.verif(c) == 0 : continue
GenereErreurPourCommande(jdc,("CALC_SENSI",))
- #### Traitement des cas particuliers ##############################
+ #### traitement des cas particuliers ##############################
# On ne traite pas les commandes TEST*
removeCommande(jdc,"TEST_COMPOR")
removeCommande(jdc,"TEST_FICHIER")
removeCommande(jdc,"TEST_TABLE")
removeCommande(jdc,"TEST_TEMPS")
- #### Traitement de AFFE_CARA_ELEM ##############################
+ #### traitement de AFFE_CARA_ELEM ##############################
# Déplacement de PREC_AIRE et PREC_INERTIE dans MULTIFIBRE
moveMotCleFromFactToFact(jdc,"AFFE_CARA_ELEM","POUTRE","PREC_AIRE","MULTIFIBRE")
removeMotCleInFact(jdc,"AFFE_CARA_ELEM","POUTRE","PREC_AIRE",pasDeRegle(),0)
# Suppression de ORIG_AXE
removeMotCleInFact(jdc,"AFFE_CARA_ELEM","GRILLE","ORIG_AXE",pasDeRegle(),0)
- #### Traitement de AFFE_CHAR_MECA/_F ##############################
+ #### traitement de AFFE_CHAR_MECA/_F ##############################
renameMotCle(jdc,"AFFE_CHAR_MECA","SIGM_INTERNE","PRE_SIGM")
renameMotCle(jdc,"AFFE_CHAR_MECA","EPSI_INIT","PRE_EPSI")
renameMotCle(jdc,"AFFE_CHAR_MECA_F","SIGM_INTERNE","PRE_SIGM")
renameMotCle(jdc,"AFFE_CHAR_MECA_F","EPSI_INIT","PRE_EPSI")
- #### Traitement de AFFE_CHAR_OPS011 ##############################
+ #### traitement de AFFE_CHAR_OPS011 ##############################
GenereErreurPourCommande(jdc,("AFFE_CHAR_OPS011",))
- #### Traitement de AFFE_CHAR_THER/_F ##############################
+ #### traitement de AFFE_CHAR_THER/_F ##############################
renameMotCle(jdc,"AFFE_CHAR_THER","GRAD_TEMP_INIT","PRE_GRAD_TEMP")
renameMotCle(jdc,"AFFE_CHAR_THER_F","GRAD_TEMP_INIT","PRE_GRAD_TEMP")
- #### Traitement de AFFE_MATERIAU ##############################
+ #### traitement de AFFE_MATERIAU ##############################
# VALE_REF obligatoire si NOM_VARC in ('TEMP', 'SECH')
lNOMVARC=["CORR","IRRA","HYDR","EPSA","M_ACIER","M_ZIRC","NEUT1","NEUT2"]
removeMotCleInFactSiRegle(jdc,"AFFE_MATERIAU","AFFE_VARC","VALE_REF",((("NOM_VARC",lNOMVARC,jdc),"MCsousMCFcourantaPourValeurDansListe"),))
# renommage CHAMP_GD en CHAM_GD
renameMotCleInFact(jdc,"AFFE_MATERIAU","AFFE_VARC","CHAMP_GD","CHAM_GD",pasDeRegle(),0)
- #### Traitement de AFFE_MODELE ##############################
+ #### traitement de AFFE_MODELE ##############################
dXFEMCONT={"3D_XFEM_CONT":"3D","C_PLAN_XFEM_CONT":"C_PLAN","D_PLAN_XFEM_CONT":"D_PLAN"}
ChangementValeurDsMCF(jdc,"AFFE_MODELE","AFFE","MODELISATION",dXFEMCONT)
- #### Traitement de ASSE_ELEM_SSD ##############################
+ #### traitement de ASSE_ELEM_SSD ##############################
# Rien à faire
- #### Traitement de ASSEMBLAGE ##############################
+ #### traitement de ASSEMBLAGE ##############################
# Rien à faire, n'existe pas en 10
- #### Traitement de C_COMP_INCR ##############################
+ #### traitement de C_COMP_INCR ##############################
# Suppression de ALGO_C_PLAN et ALGO_1D
lCOMMANDE=["CALC_FORC_NONL","CALC_IFS_DNL","CALC_POINT_MAT",
"CALC_PRECONT","CALCUL","DYNA_NON_LINE","LIRE_RESU",
renameMotCleInFact(jdc,com,"COMP_INCR","RESI_DEBO_RELA","RESI_CPLAN_RELA",pasDeRegle(),0)
renameMotCleInFact(jdc,com,"COMP_INCR","ITER_MAXI_DEBORST","ITER_CPLAN_MAXI",pasDeRegle(),0)
- #### Traitement de C_NEWTON ##############################
+ #### traitement de C_NEWTON ##############################
# Renommage de EXTRAPOL en EXTRAPOLE
lCOMMANDE=["CALC_IFS_DNL","CALC_POINT_MAT","CALC_PRECONT",
"DYNA_NON_LINE","MACR_ASCOUF_CALC","MACR_ASPIC_CALC",
for com in lCOMMANDE :
ChangementValeurDsMCF(jdc,com,"NEWTON","PREDICTION",dPRED)
- #### Traitement de C_SOLVEUR ##############################
+ #### traitement de C_SOLVEUR ##############################
# Renommage de EXTRAPOL en EXTRAPOLE
lCOMMANDE=["CALC_ELEM","CALC_FORC_AJOU","CALC_IFS_DNL",
"CALC_MATR_AJOU","CALC_PRECONT","CREA_ELEM_SSD",
removeMotCleInFact(jdc,com,"SOLVEUR","OUT_OF_CORE",pasDeRegle(),0)
removeMotCleInFact(jdc,com,"SOLVEUR","LIBERE_MEMOIRE",pasDeRegle(),0)
- #### Traitement de CALC_CHAMP ##############################
+ #### traitement de CALC_CHAMP ##############################
# Rien à faire, n'existe pas en 10
- #### Traitement de CALC_ECREVISSE ##############################
+ #### traitement de CALC_ECREVISSE ##############################
# Rien à faire
- #### Traitement de CALC_ELEM ##############################
+ #### traitement de CALC_ELEM ##############################
# renommage de la commande
renameCommande(jdc,"CALC_ELEM","CALC_CHAMP", )
# Suppression des types de charges
removeMotCle(jdc,"CALC_CHAMP","META",pasDeRegle(),0)
removeMotCle(jdc,"CALC_CHAMP","ERREUR",pasDeRegle(),0)
- #### Traitement de CALC_ERREUR ##############################
+ #### traitement de CALC_ERREUR ##############################
# Rien à faire, n'existe pas en 10
- #### Traitement de CALC_ESSAI ##############################
+ #### traitement de CALC_ESSAI ##############################
# Rien à faire
- #### Traitement de CALC_EUROPLEXUS ##############################
+ #### traitement de CALC_EUROPLEXUS ##############################
# Rien à faire
- #### Traitement de CALC_FATIGUE ##############################
+ #### traitement de CALC_FATIGUE ##############################
# Rien à faire
- #### Traitement de CALC_FERRAILLAGE ##############################
+ #### traitement de CALC_FERRAILLAGE ##############################
# Rien à faire
- #### Traitement de CALC_FONCTION ##############################
+ #### traitement de CALC_FONCTION ##############################
# Rien à faire
- #### Traitement de CALC_FORC_AJOU ##############################
+ #### traitement de CALC_FORC_AJOU ##############################
# Rien à faire
- #### Traitement de CALC_G ##############################
+ #### traitement de CALC_G ##############################
# Suppression SYME_CHAR
removeMotCle(jdc,"CALC_G","SYME_CHAR",pasDeRegle(),0)
# Règle sur DEGRE
removeMotCleInFactSiRegle(jdc,"CALC_G","THETA","THETA",((("THETA","FOND_FISS",),"existeMCsousMCF"),))
removeMotCleInFactSiRegle(jdc,"CALC_G","THETA","THETA",((("THETA","FISSURE",),"existeMCsousMCF"),))
- #### Traitement de CALC_IFS_DNL ##############################
+ #### traitement de CALC_IFS_DNL ##############################
# Renommage CRIT_FLAMB en CRIT_STAB
renameMotCle(jdc,"CALC_IFS_DNL","CRIT_FLAMB","CRIT_STAB")
removeMotCleInFact(jdc,"CALC_IFS_DNL","CRIT_FLAMB","INST_CALCUL",pasDeRegle(),1)
# Suppression de ARCHIVAGE/DETR_NUME_SUIV
removeMotCleInFact(jdc,"CALC_IFS_DNL","ARCHIVAGE","DETR_NUME_SUIV",pasDeRegle(),0)
- #### Traitement de CALC_INTE_SPEC ##############################
+ #### traitement de CALC_INTE_SPEC ##############################
# Rien à faire
- #### Traitement de CALC_MAC3COEUR ##############################
+ #### traitement de CALC_MAC3COEUR ##############################
# Rien à faire, n'existe pas en 10
- #### Traitement de CALC_MATR_AJOU ##############################
+ #### traitement de CALC_MATR_AJOU ##############################
# Suppression d'algo pour PETSc
removeMotCleSiRegle(jdc,"RESOUDRE","ALGORITHME",((("BCGS","BICG","TFQMR",),"MCaPourValeur"),))
- #### Traitement de CALC_MATR_ELEM ##############################
+ #### traitement de CALC_MATR_ELEM ##############################
# Rien à faire
- #### Traitement de CALC_META ##############################
+ #### traitement de CALC_META ##############################
# OPTION est obligatoire
chercheOperInsereFacteurSiRegle(jdc,"CALC_META","OPTION='META_ELNO'",((("OPTION",),"nexistepas"),),0)
- #### Traitement de CALC_MISS ##############################
+ #### traitement de CALC_MISS ##############################
# Suppression de TYPE_CHARGE
removeMotCle(jdc,"CALC_MISS","TYPE_CHARGE",pasDeRegle(),0)
- #### Traitement de CALC_MODAL ##############################
+ #### traitement de CALC_MODAL ##############################
# renommage de STOP_FREQ_VIDE
renameMotCle(jdc,"CALC_MODAL","STOP_FREQ_VIDE","STOP_BANDE_VIDE")
- #### Traitement de CALC_MODE_ROTATION ##############################
+ #### traitement de CALC_MODE_ROTATION ##############################
# renommage de MATR_A et MATR_B
renameMotCle(jdc,"CALC_MODE_ROTATION","MATR_A","MATR_RIGI")
renameMotCle(jdc,"CALC_MODE_ROTATION","MATR_B","MATR_MASS")
- #### Traitement de CALC_NO ##############################
+ #### traitement de CALC_NO ##############################
# renommage de la commande
renameCommande(jdc,"CALC_NO","CALC_CHAMPNO", )
# Suppression des types de charges
removeMotCle(jdc,"CALC_CHAMP","METANO",pasDeRegle(),0)
removeMotCle(jdc,"CALC_CHAMP","ERREURNO",pasDeRegle(),0)
- #### Traitement de CALC_POINT_MAT ##############################
+ #### traitement de CALC_POINT_MAT ##############################
# Rien à faire
- #### Traitement de CALC_PRECONT ##############################
+ #### traitement de CALC_PRECONT ##############################
# Renommage de IMPLEX
ChangementValeur(jdc,"CALC_PRECONT","METHODE",{"IMPL_EX":"IMPLEX"})
removeMotCle(jdc,"CALC_PRECONT","IMPL_EX",pasDeRegle(),0)
- #### Traitement de CALC_SENSI ##############################
+ #### traitement de CALC_SENSI ##############################
# Résorption de la sensibilité
removeCommande(jdc,"CALC_SENSI")
#GenereErreurPourCommande(jdc,("CALC_SENSI",))
- #### Traitement de CALC_SPEC ##############################
+ #### traitement de CALC_SPEC ##############################
# Déplacement d'un mot-clé facteur facteur
moveMotCleFromFactToFather(jdc,"CALC_SPEC","TAB_ECHANT","LONGUEUR_ECH")
moveMotCleFromFactToFather(jdc,"CALC_SPEC","LONGUEUR_ECH","DUREE")
moveMotClefInOperToFact(jdc,"CALC_SPEC","RECOUVREMENT_POURCENT","TAB_ECHANT")
moveMotClefInOperToFact(jdc,"CALC_SPEC","RECOUVREMENT_NB_PTS","TAB_ECHANT")
- #### Traitement de CALC_TABLE ##############################
+ #### traitement de CALC_TABLE ##############################
# Renommage de AJOUT en AJOUT_LIGNE
dOPE={"AJOUT":"AJOUT_LIGNE",}
ChangementValeurDsMCF(jdc,"CALC_TABLE","ACTION","OPERATION",dOPE)
dCRIT={"ABS_MAXI":"MAXI_ABS","ABS_MINI":"MINI_ABS"}
ChangementValeurDsMCF(jdc,"CALC_TABLE","FILTRE","CRIT_COMP",dCRIT)
- #### Traitement de CALC_THETA ##############################
+ #### traitement de CALC_THETA ##############################
# Résorption de la sensibilité
removeMotCle(jdc,"CALC_THETA","OPTION",pasDeRegle(),0)
removeMotCle(jdc,"CALC_THETA","THETA_BANDE",pasDeRegle(),1)
removeMotCle(jdc,"CALC_THETA","GRAD_NOEU_THETA",pasDeRegle(),0)
- #### Traitement de COMB_FOURIER ##############################
+ #### traitement de COMB_FOURIER ##############################
# Homogénéisation de ANGLE
renameMotCle(jdc,"COMB_FOURIER","ANGL","ANGLE")
- #### Traitement de COMB_SISM_MODAL ##############################
+ #### traitement de COMB_SISM_MODAL ##############################
GenereErreurValeur(jdc,"COMB_SISM_MODAL","OPTION",("'EFCA_ELNO'",))
- #### Traitement de CREA_CHAMP ##############################
+ #### traitement de CREA_CHAMP ##############################
removeMotCle(jdc,"CREA_CHAMP","SENSIBILITE",pasDeRegle(),0)
removeMotCle(jdc,"CREA_CHAMP","PROL_ZERO",pasDeRegle(),0)
- #### Traitement de CREA_ELEM_SSD ##############################
+ #### traitement de CREA_ELEM_SSD ##############################
# Rien à faire
- #### Traitement de CREA_MAILLAGE ##############################
+ #### traitement de CREA_MAILLAGE ##############################
# Suppression de la possibilité de copier un maillage
lFACTEUR=['COQU_VOLU', 'CREA_FISS', 'CREA_GROUP_MA', 'CREA_MAILLE', 'CREA_POI1',
'DETR_GROUP_MA', 'ECLA_PG', 'HEXA20_27', 'LINE_QUAD', 'MODI_MAILLE',
renameCommandeSiRegle(jdc,"CREA_MAILLAGE","COPIER",(((lFACTEUR),"nexistepasMCFParmi"),))
renameMotCle(jdc,"COPIER","MAILLAGE","CONCEPT")
- #### Traitement de CREA_RESU ##############################
+ #### traitement de CREA_RESU ##############################
# Rien à faire
- #### Traitement de CREA_TABLE ##############################
+ #### traitement de CREA_TABLE ##############################
removeMotCle(jdc,"CREA_TABLE","SENSIBILITE",pasDeRegle(),0)
- #### Traitement de DEBUT ##############################
+ #### traitement de DEBUT ##############################
# Suppression du mot-clé TITRE
removeMotCleInFact(jdc,"DEBUT","CATALOGUE","TITRE",pasDeRegle(),0)
# Suppression du mot-clé IMPRESSION
removeMotCleInFact(jdc,"DEBUT","MEMOIRE","PARTITION",pasDeRegle(),0)
removeMotCleInFact(jdc,"DEBUT","MEMOIRE","DYNAMIQUE",pasDeRegle(),0)
- #### Traitement de DEFI_BASE_MODALE ##############################
+ #### traitement de DEFI_BASE_MODALE ##############################
# Rien à faire
- #### Traitement de DEFI_CABLE_BP ##############################
+ #### traitement de DEFI_CABLE_BP ##############################
# Rien à faire
- #### Traitement de DEFI_COMPOR ##############################
+ #### traitement de DEFI_COMPOR ##############################
# Suppression famille de sytèmes de glissement
lFAMGLIS=["'BASAL'", "'PRISMATIQUE'","'PYRAMIDAL1'","'PYRAMIDAL2'","'MACLAGE'",]
GenereErreurValeurDsMCF(jdc,"DEFI_COMPOR","MONOCRISTAL","FAMI_SYST_GLIS",lFAMGLIS)
# Suppression de DEFORMATION
GenereErreurMotCleInFact(jdc,"DEFI_COMPOR","MULTIFIBRE","DEFORMATION")
- #### Traitement de DEFI_CONTACT ##############################
+ #### traitement de DEFI_CONTACT ##############################
GenereErreurValeurDsMCF(jdc,"DEFI_CONTACT","ZONE","ALGO_CONT",("'AVANCE'",))
GenereErreurValeurDsMCF(jdc,"DEFI_CONTACT","ZONE","ALGO_FROT",("'AVANCE'",))
# résorption de RACCORD_LINE_QUAD et éléments de Barsoum
# Ajout règle sur REAC_GEOM
removeMotCleSiRegle(jdc,"DEFI_CONTACT","REAC_GEOM",((("ALGO_RESO_GEOM","NEWTON",jdc),"MCaPourValeur"),))
- #### Traitement de DEFI_COQU_MULT ##############################
+ #### traitement de DEFI_COQU_MULT ##############################
renameCommande(jdc,"DEFI_COQU_MULT","DEFI_COMPOSITE", )
- #### Traitement de DEFI_FICHIER ##############################
+ #### traitement de DEFI_FICHIER ##############################
# Rien à faire
- #### Traitement de DEFI_FISS_XFEM ##############################
+ #### traitement de DEFI_FISS_XFEM ##############################
# Suppression de ORIE_FOND
removeMotCle(jdc,"DEFI_FISS_XFEM","ORIE_FOND",pasDeRegle(),0)
# Fusion FORM_FISS='ELLIPSE' et FORM_FISS='INCLUSION'
dFORME={"INCLUSION":"ELLIPSE",}
ChangementValeurDsMCF(jdc,"DEFI_FISS_XFEM","DEFI_FISS","FORM_FISS",dOPE)
- #### Traitement de DEFI_FONC_ELEC ##############################
+ #### traitement de DEFI_FONC_ELEC ##############################
# Rien à faire
- #### Traitement de DEFI_FOND_FISS ##############################
+ #### traitement de DEFI_FOND_FISS ##############################
renameMotCle(jdc,"DEFI_FOND_FISS","FOND_FISS","FONDFISS")
# Cas FOND OUVERT
AjouteMotClefDansFacteurCourantSiRegle(jdc,"DEFI_FOND_FISS","FONDFISS","TYPE_FOND='OUVERT'",((("FONDFISS",),"existe"),))
#
renameMotCle(jdc,"DEFI_FOND_FISS","FONDFISS","FOND_FISS")
- #### Traitement de DEFI_GLRC ##############################
+ #### traitement de DEFI_GLRC ##############################
# Renommage de mot-clés
renameMotCle(jdc,"DEFI_GLRC","GC","GAMMA_C")
renameMotCle(jdc,"DEFI_GLRC","SYC","NYC")
renameMotCle(jdc,"DEFI_GLRC","EPSI_FLEX","KAPPA_FLEX")
- #### Traitement de DEFI_GROUPE ##############################
+ #### traitement de DEFI_GROUPE ##############################
# Rien à faire
- #### Traitement de DEFI_INTE_SPEC ##############################
+ #### traitement de DEFI_INTE_SPEC ##############################
# Rien à faire
- #### Traitement de DEFI_LIST_INST ##############################
+ #### traitement de DEFI_LIST_INST ##############################
dMETHODE={"UNIFORME":"MANUEL","EXTRAPOLE":"MANUEL","AUCUNE":"AUTO"}
ChangementValeurDsMCF(jdc,"DEFI_LIST_INST","ECHEC","SUBD_METHODE",dMETHODE)
removeMotCleInFact(jdc,"DEFI_LIST_INST","ECHEC","SUBD_COEF_PAS_1",pasDeRegle(),0)
- #### Traitement de DEFI_MATER_GC ##############################
+ #### traitement de DEFI_MATER_GC ##############################
# Rien à faire, n'existe pas en 10
- #### Traitement de DEFI_MATERIAU ##############################
+ #### traitement de DEFI_MATERIAU ##############################
# Suppression des critères pour les poutres
GenereErreurMCF(jdc,"DEFI_MATERIAU","ECRO_FLEJOU")
GenereErreurMCF(jdc,"DEFI_MATERIAU","VMIS_POUTRE")
# Suppression de la loi MONO_DD_CC
GenereErreurMCF(jdc,"DEFI_MATERIAU","MONO_DD_CC")
- #### Traitement de DEFI_NAPPE ##############################
+ #### traitement de DEFI_NAPPE ##############################
# Rien à faire
- #### Traitement de DEFI_PARA_SENSI ##############################
+ #### traitement de DEFI_PARA_SENSI ##############################
# Résorption de la sensibilité
removeCommande(jdc,"DEFI_PARA_SENSI")
#GenereErreurPourCommande(jdc,("DEFI_PARA_SENSI",))
- #### Traitement de DEFI_PART_FETI ##############################
+ #### traitement de DEFI_PART_FETI ##############################
# Rien à faire
- #### Traitement de DEFI_SOL_MISS ##############################
+ #### traitement de DEFI_SOL_MISS ##############################
# Rien à faire
- #### Traitement de DEFI_SPEC_TURB ##############################
+ #### traitement de DEFI_SPEC_TURB ##############################
# Homogénéisation de ANGLE
renameMotCleInFact(jdc,"DEFI_SPEC_TURB","SPEC_EXCI_POINT","ANGL","ANGLE",pasDeRegle(),0)
- #### Traitement de DETRUIRE ##############################
+ #### traitement de DETRUIRE ##############################
# Résorption de la sensibilité
removeMotCleInFact(jdc,"DETRUIRE","CONCEPT","SENSIBILITE",pasDeRegle(),0)
# Suppression mot-clé ALARME
removeMotCle(jdc,"DETRUIRE","ALARME",pasDeRegle(),0)
- #### Traitement de DYNA_ALEA_MODAL ##############################
+ #### traitement de DYNA_ALEA_MODAL ##############################
# Rien à faire
- #### Traitement de DYNA_ISS_VARI ##############################
+ #### traitement de DYNA_ISS_VARI ##############################
AjouteMotClefDansFacteurCourantSiRegle(jdc,"DYNA_ISS_VARI","MATR_COHE","TYPE='MITA_LUCO'",((("MATR_COHE",),"existe"),))
- #### Traitement de DYNA_LINE_HARM ##############################
+ #### traitement de DYNA_LINE_HARM ##############################
# Résorption de la sensibilité
removeMotCle(jdc,"DYNA_LINE_HARM","SENSIBILITE",pasDeRegle(),0)
# Suppression mot-clé TYPE_CHARGE
moveMotClefInOperToFact(jdc,"DYNA_LINE_HARM","AMOR_REDUIT","AMOR_MODAL")
moveMotClefInOperToFact(jdc,"DYNA_LINE_HARM","LIST_AMOR","AMOR_MODAL")
- #### Traitement de DYNA_LINE_TRAN ##############################
+ #### traitement de DYNA_LINE_TRAN ##############################
# Résorption de la sensibilité
removeMotCle(jdc,"DYNA_LINE_TRAN","SENSIBILITE",pasDeRegle(),0)
# Ajout SCHEMA_TEMPS
# Renommage dans ARCHIVAGE
renameMotCleInFact(jdc,"DYNA_LINE_TRAN","ARCHIVAGE","LIST_ARCH","LIST_INST",pasDeRegle(),0)
- #### Traitement de DYNA_NON_LINE ##############################
+ #### traitement de DYNA_NON_LINE ##############################
# Renommage CRIT_FLAMB en CRIT_STAB
renameMotCle(jdc,"DYNA_NON_LINE","CRIT_FLAMB","CRIT_STAB")
# Résorption de la sensibilité
# Suppression de ARCHIVAGE/DETR_NUME_SUIV
removeMotCleInFact(jdc,"DYNA_NON_LINE","ARCHIVAGE","DETR_NUME_SUIV",pasDeRegle(),0)
- #### Traitement de DYNA_SPEC_MODAL ##############################
+ #### traitement de DYNA_SPEC_MODAL ##############################
# Rien à faire
- #### Traitement de DYNA_TRAN_MODAL ##############################
+ #### traitement de DYNA_TRAN_MODAL ##############################
# Ajout SCHEMA_TEMPS
chercheOperInsereFacteur(jdc,"DYNA_TRAN_MODAL","SCHEMA_TEMPS")
chercheOperInsereMotCleSiRegle(jdc,"DYNA_TRAN_MODAL","METHODE='EULER'",((("METHODE",),"nexistepas"),),)
moveMotClefInOperToFact(jdc,"DYNA_TRAN_MODAL","LAMBDA","PARA_LAMEFLUI")
renameMotCle(jdc,"DYNA_TRAN_MODAL","PARA_LAMEFLUI","PARA_LAME_FLUI")
- #### Traitement de DYNA_VIBRA ##############################
+ #### traitement de DYNA_VIBRA ##############################
# Rien à faire, n'existe pas en 10
- #### Traitement de EXEC_LOGICIEL ##############################
+ #### traitement de EXEC_LOGICIEL ##############################
# Rien à faire
- #### Traitement de EXTR_RESU ##############################
+ #### traitement de EXTR_RESU ##############################
# Résorption de la sensibilité
removeMotCle(jdc,"EXTR_RESU","SENSIBILITE",pasDeRegle(),0)
- #### Traitement de EXTR_TABLE ##############################
+ #### traitement de EXTR_TABLE ##############################
# Renommage critere table
dCRIT={"ABS_MAXI":"MAXI_ABS","ABS_MINI":"MINI_ABS"}
ChangementValeurDsMCF(jdc,"RECU_TABLE","FILTRE","CRIT_COMP",dCRIT)
- #### Traitement de FACTORISER ##############################
+ #### traitement de FACTORISER ##############################
# Suppression de RENUM
removeMotCleSiRegle(jdc,"FACTORISER","RENUM",((("PRE_COND","LDLT_INC",jdc),"MCaPourValeur"),))
removeMotCleSiRegle(jdc,"FACTORISER","RENUM",((("PRE_COND","LDLT_SP",jdc),"MCaPourValeur"),))
dMEM={"OUI":"OUT_OF_CORE","NON":"IN_CORE"}
ChangementValeur(jdc,"FACTORISER","GESTION_MEMOIRE",dCRIT)
- #### Traitement de FORMULE ##############################
+ #### traitement de FORMULE ##############################
# Rien à faire
- #### Traitement de GENE_ACCE_SEISME ##############################
+ #### traitement de GENE_ACCE_SEISME ##############################
# Rien à faire, n'existe pas en 10
- #### Traitement de GENE_FONC_ALEA ##############################
+ #### traitement de GENE_FONC_ALEA ##############################
# Rien à faire
- #### Traitement de GENE_VARI_ALEA ##############################
+ #### traitement de GENE_VARI_ALEA ##############################
# Rien à faire
- #### Traitement de IMPR_CO ##############################
+ #### traitement de IMPR_CO ##############################
# Résorption de la sensibilité
removeMotCleInFact(jdc,"IMPR_CO","CONCEPT","SENSIBILITE",pasDeRegle(),0)
- #### Traitement de IMPR_DIAG_CAMPBELL ##############################
+ #### traitement de IMPR_DIAG_CAMPBELL ##############################
# Rien à faire
- #### Traitement de IMPR_FONCTION ##############################
+ #### traitement de IMPR_FONCTION ##############################
# Rien à faire
- #### Traitement de IMPR_GENE ##############################
+ #### traitement de IMPR_GENE ##############################
# Rien à faire
- #### Traitement de IMPR_OAR ##############################
+ #### traitement de IMPR_OAR ##############################
# Rien à faire
- #### Traitement de IMPR_RESU ##############################
+ #### traitement de IMPR_RESU ##############################
# Résorption de la sensibilité
removeMotCleInFact(jdc,"IMPR_RESU","RESU","SENSIBILITE",pasDeRegle(),0)
# Suppression de l'écriture au format ENSIGHT
# Suppression mot-clé MODELE
removeMotCle(jdc,"IMPR_RESU","MODELE",pasDeRegle(),0)
- #### Traitement de IMPR_STURM ##############################
+ #### traitement de IMPR_STURM ##############################
renameMotCle(jdc,"IMPR_STURM","TYPE_RESU","TYPE_MODE")
# renommage de MATR_A, MATR_B et MATR_C
renameMotCleSiRegle(jdc,"IMPR_STURM","MATR_A","MATR_RIGI",((("TYPE_MODE","DYNAMIQUE",jdc),"MCaPourValeur"),),1)
# Renommage de la commande
renameCommande(jdc,"IMPR_STURM","INFO_MODE", )
- #### Traitement de IMPR_TABLE ##############################
+ #### traitement de IMPR_TABLE ##############################
# Résorption de la sensibilité
removeMotCle(jdc,"IMPR_TABLE","SENSIBILITE",pasDeRegle(),0)
# Renommage critere table
# Suppression de FORMAT_C
GenereErreurMCF(jdc,"IMPR_TABLE","FORMAT_C")
- #### Traitement de INCLUDE ##############################
+ #### traitement de INCLUDE ##############################
# Rien à faire
- #### Traitement de INCLUDE_MATERIAU ##############################
+ #### traitement de INCLUDE_MATERIAU ##############################
# Rien à faire
- #### Traitement de INFO_EXEC_ASTER ##############################
+ #### traitement de INFO_EXEC_ASTER ##############################
# Rien à faire
- #### Traitement de INFO_FONCTION ##############################
+ #### traitement de INFO_FONCTION ##############################
# Rien à faire
- #### Traitement de INFO_MODE ##############################
+ #### traitement de INFO_MODE ##############################
# Rien à faire, n'existe pas en 10
- #### Traitement de LIRE_CHAMP ##############################
+ #### traitement de LIRE_CHAMP ##############################
# Rien à faire
- #### Traitement de LIRE_FONCTION ##############################
+ #### traitement de LIRE_FONCTION ##############################
# Rien à faire
- #### Traitement de LIRE_IMPE_MISS ##############################
+ #### traitement de LIRE_IMPE_MISS ##############################
# Rien à faire
- #### Traitement de LIRE_INTE_SPEC ##############################
+ #### traitement de LIRE_INTE_SPEC ##############################
# Rien à faire
- #### Traitement de LIRE_MAILLAGE ##############################
+ #### traitement de LIRE_MAILLAGE ##############################
# Rien à faire
- #### Traitement de LIRE_RESU ##############################
+ #### traitement de LIRE_RESU ##############################
# Suppression du type HARM_GENE
GenereErreurValeur(jdc,"LIRE_RESU","TYPE_RESU",("'HARM_GENE'",))
# renommage de MATR_A et MATR_B
GenereErreurValeurDsMCF(jdc,"LIRE_RESU","FORMAT_MED","NOM_CHAM",lSUPCHAMPS)
GenereErreurValeur(jdc,"LIRE_RESU","NOM_CHAM",lSUPCHAMPS)
- #### Traitement de LIRE_TABLE ##############################
+ #### traitement de LIRE_TABLE ##############################
# Rien à faire
- #### Traitement de MACR_ADAP_MAIL ##############################
+ #### traitement de MACR_ADAP_MAIL ##############################
# Résorption de la sensibilité
removeMotCle(jdc,"MACR_ADAP_MAIL","SENSIBILITE",pasDeRegle(),0)
# Changement de version
renameMotCle(jdc,"MACR_ADAP_MAIL","ELEMENTS_NON_HOMARD","ELEMENTS_ACCEPTES")
ChangementValeur(jdc,"MACR_ADAP_MAIL","ELEMENTS_ACCEPTES",{"REFUSER":"HOMARD","IGNORER":"IGNORE_PYRA"})
- #### Traitement de MACR_ASCOUF_CALC ##############################
+ #### traitement de MACR_ASCOUF_CALC ##############################
# Rien à faire
- #### Traitement de MACR_ASCOUF_MAIL ##############################
+ #### traitement de MACR_ASCOUF_MAIL ##############################
# Rien à faire
- #### Traitement de MACR_ASPIC_CALC ##############################
+ #### traitement de MACR_ASPIC_CALC ##############################
# Rien à faire
- #### Traitement de MACR_ASPIC_MAIL ##############################
+ #### traitement de MACR_ASPIC_MAIL ##############################
# Rien à faire
- #### Traitement de MACR_CARA_POUTRE ##############################
+ #### traitement de MACR_CARA_POUTRE ##############################
renameMotCle(jdc,"MACR_CARA_POUTRE","SYME_Y","SYME_ZZ")
renameMotCle(jdc,"MACR_CARA_POUTRE","SYME_X","SYME_Y")
renameMotCle(jdc,"MACR_CARA_POUTRE","SYME_ZZ","SYME_Z")
- #### Traitement de MACR_ECLA_PG ##############################
+ #### traitement de MACR_ECLA_PG ##############################
# Rien à faire
- #### Traitement de MACR_ECRE_CALC ##############################
+ #### traitement de MACR_ECRE_CALC ##############################
# Changement de version
ChangementValeur(jdc,"MACR_ECRE_CALC","VERSION",{"3.1.1":"3.2.1","3.1.2":"3.2.1","3.2":"3.2.1"})
- #### Traitement de MACR_ECREVISSE ##############################
+ #### traitement de MACR_ECREVISSE ##############################
# Changement de version
ChangementValeur(jdc,"MACR_ECRE_CALC","VERSION",{"3.1.1":"3.2.1","3.1.2":"3.2.1","3.2":"3.2.1"})
- #### Traitement de MACR_ELEM_DYNA ##############################
+ #### traitement de MACR_ELEM_DYNA ##############################
# Rien à faire
- #### Traitement de MACR_FIABILITE ##############################
+ #### traitement de MACR_FIABILITE ##############################
GenereErreurPourCommande(jdc,("MACR_FIABILITE",))
- #### Traitement de MACR_FIAB_IMPR ##############################
+ #### traitement de MACR_FIAB_IMPR ##############################
GenereErreurPourCommande(jdc,("MACR_FIAB_IMPR",))
- #### Traitement de MACR_INFO_MAIL ##############################
+ #### traitement de MACR_INFO_MAIL ##############################
# Changement de version
ChangementValeur(jdc,"MACR_INFO_MAIL","VERSION_HOMARD",{"V10_1":"V10_6"})
# Renommage du mot-clé ELEMENTS_NON_HOMARD
renameMotCle(jdc,"MACR_INFO_MAIL","ELEMENTS_NON_HOMARD","ELEMENTS_ACCEPTES")
ChangementValeur(jdc,"MACR_INFO_MAIL","ELEMENTS_ACCEPTES",{"REFUSER":"HOMARD","IGNORER":"IGNORE_PYRA"})
- #### Traitement de MACR_LIGN_COUPE ##############################
+ #### traitement de MACR_LIGN_COUPE ##############################
# Rien à faire
- #### Traitement de MACRO_ELAS_MULT ##############################
+ #### traitement de MACRO_ELAS_MULT ##############################
# Résorption de NUME_COUCHE NIVE_COUCHE
removeMotCleInFact(jdc,"MACRO_ELAS_MULT","CAS_CHARGE","NUME_COUCHE",pasDeRegle(),0)
removeMotCleInFact(jdc,"MACRO_ELAS_MULT","CAS_CHARGE","NIVE_COUCHE",pasDeRegle(),0)
"'EPEQ_NOEU'","'FLUX_NOEU'",]
GenereErreurValeurDsMCF(jdc,"MACRO_ELAS_MULT","CAS_CHARGE","OPTION",lOPT)
- #### Traitement de MACRO_EXPANS ##############################
+ #### traitement de MACRO_EXPANS ##############################
# Rien à faire
- #### Traitement de MACRO_MATR_AJOU ##############################
+ #### traitement de MACRO_MATR_AJOU ##############################
# Rien à faire
- #### Traitement de MACRO_MATR_ASSE ##############################
+ #### traitement de MACRO_MATR_ASSE ##############################
# Suppression de paramètres mémoire
removeMotCleInFact(jdc,"MACRO_MATR_ASSE","SOLVEUR","OUT_OF_CORE",pasDeRegle(),0)
removeMotCleInFact(jdc,"MACRO_MATR_ASSE","SOLVEUR","LIBERE_MEMOIRE",pasDeRegle(),0)
# Renommage de la commande
renameCommande(jdc,"MACRO_MATR_ASSE","ASSEMBLAGE", )
- #### Traitement de MACRO_MISS_3D ##############################
+ #### traitement de MACRO_MISS_3D ##############################
# Rien à faire
- #### Traitement de MACRO_MODE_MECA ##############################
+ #### traitement de MACRO_MODE_MECA ##############################
# renommage de MATR_A et MATR_B
renameMotCle(jdc,"MACRO_MODE_MECA","MATR_A","MATR_RIGI")
renameMotCle(jdc,"MACRO_MODE_MECA","MATR_B","MATR_MASS")
# Renommage critere de Sturm
ChangementValeurDsMCF(jdc,"MACRO_MODE_MECA","VERI_MODE","STURM",{"OUI":"GLOBAL",})
- #### Traitement de MACRO_PROJ_BASE ##############################
+ #### traitement de MACRO_PROJ_BASE ##############################
renameMotCle(jdc,"MACRO_PROJ_BASE","PROFIL","STOCKAGE")
# Renommage de la commande
renameCommande(jdc,"MACRO_PROJ_BASE","PROJ_BASE", )
- #### Traitement de MACR_RECAL ##############################
+ #### traitement de MACR_RECAL ##############################
renameMotCle(jdc,"MACR_RECAL","POIDS","LIST_POIDS")
- #### Traitement de MACR_SPECTRE ##############################
+ #### traitement de MACR_SPECTRE ##############################
# Rien à faire
- #### Traitement de MECA_STATIQUE ##############################
+ #### traitement de MECA_STATIQUE ##############################
# Résorption de la sensibilité
removeMotCle(jdc,"MECA_STATIQUE","SENSIBILITE",pasDeRegle(),0)
- #### Traitement de MODE_ITER_INV ##############################
+ #### traitement de MODE_ITER_INV ##############################
# Résorption de la sensibilité
removeMotCle(jdc,"MODE_ITER_INV","SENSIBILITE",pasDeRegle(),0)
# renommage de MATR_A, MATR_B et MATR_C
renameMotCle(jdc,"MODE_ITER_INV","MATR_A","MATR_RIGI")
renameMotCle(jdc,"MODE_ITER_INV","MATR_B","MATR_MASS")
- #### Traitement de MODE_ITER_SIMULT ##############################
+ #### traitement de MODE_ITER_SIMULT ##############################
# Résorption de la sensibilité
removeMotCle(jdc,"MODE_ITER_SIMULT","SENSIBILITE",pasDeRegle(),0)
# renommage de MATR_A, MATR_B et MATR_C
# renommage STOP_FREQ_VIDE
renameMotCle(jdc,"MODE_ITER_SIMULT","STOP_FREQ_VIDE","STOP_BANDE_VIDE")
- #### Traitement de MODE_STATIQUE ##############################
+ #### traitement de MODE_STATIQUE ##############################
# renommage du mot-clé FREQ
renameMotCleInFact(jdc,"MODE_STATIQUE","MODE_INTERF","FREQ","SHIFT",pasDeRegle(),0)
- #### Traitement de MODI_MODELE_XFEM ##############################
+ #### traitement de MODI_MODELE_XFEM ##############################
GenereErreurValeur(jdc,"MODI_MODELE_XFEM","CONTACT",("'P1P1A'",))
- #### Traitement de MODI_REPERE ##############################
+ #### traitement de MODI_REPERE ##############################
# renommage de DEFI_REPERE
renameMotCle(jdc,"MODI_REPERE","DEFI_REPERE","AFFE")
moveMotCleFromFactToFather(jdc,"MODI_REPERE","AFFE","REPERE")
moveMotClefInOperToFact(jdc,"MODI_REPERE","MAILLE","AFFE",)
moveMotClefInOperToFact(jdc,"MODI_REPERE","NOEUD","AFFE",)
- #### Traitement de NORM_MODE ##############################
+ #### traitement de NORM_MODE ##############################
removeMotCle(jdc,"NORM_MODE","SENSIBILITE",pasDeRegle(),0)
- #### Traitement de NUME_DDL ##############################
+ #### traitement de NUME_DDL ##############################
# Rien à faire
- #### Traitement de NUME_DDL_GENE ##############################
+ #### traitement de NUME_DDL_GENE ##############################
# Rien à faire
- #### Traitement de OBSERVATION ##############################
+ #### traitement de OBSERVATION ##############################
# renommage de MATR_A et MATR_B
renameMotCle(jdc,"OBSERVATION","MATR_A","MATR_RIGI")
renameMotCle(jdc,"OBSERVATION","MATR_B","MATR_MASS")
- #### Traitement de POST_BORDET ##############################
+ #### traitement de POST_BORDET ##############################
# Rien à faire
- #### Traitement de POST_CHAMP ##############################
+ #### traitement de POST_CHAMP ##############################
# Rien à faire, n'existe pas en 10
- #### Traitement de POST_CHAM_XFEM ##############################
+ #### traitement de POST_CHAM_XFEM ##############################
# Suppression mot-clé MAILLAGE_SAIN
removeMotCle(jdc,"POST_CHAM_XFEM","MAILLAGE_SAIN",pasDeRegle(),0)
- #### Traitement de POST_COQUE ##############################
+ #### traitement de POST_COQUE ##############################
# Rien à faire
- #### Traitement de POST_DECOLLEMENT ##############################
+ #### traitement de POST_DECOLLEMENT ##############################
# Rien à faire
- #### Traitement de POST_DYNA_ALEA ##############################
+ #### traitement de POST_DYNA_ALEA ##############################
# Suppression du mot-clé NUME_VITE_FLUI
removeMotCle(jdc,"POST_DYNA_ALEA","NUME_VITE_FLUI",pasDeRegle(),0)
- #### Traitement de POST_ELEM ##############################
+ #### traitement de POST_ELEM ##############################
# Rien à faire
- #### Traitement de POST_ENDO_FISS ##############################
+ #### traitement de POST_ENDO_FISS ##############################
# Suppression du mot-clé MODELE
removeMotCle(jdc,"POST_ENDO_FISS","MODELE",pasDeRegle(),0)
# Renommage de SEUIL
renameMotCleInFact(jdc,"POST_ENDO_FISS","RECHERCHE","SEUIL","BORNE_MIN",pasDeRegle(),0)
- #### Traitement de POST_FATIGUE ##############################
+ #### traitement de POST_FATIGUE ##############################
# Suppression du chargement periodique
GenereErreurValeur(jdc,"POST_FATIGUE","CHARGEMENT",("'PERIODIQUE'",))
- #### Traitement de POST_GP ##############################
+ #### traitement de POST_GP ##############################
# Suppression de POST_GP au profit de CALC_GP
GenereErreurPourCommande(jdc,("POST_GP",))
- #### Traitement de POST_K1_K2_K3 ##############################
+ #### traitement de POST_K1_K2_K3 ##############################
# Suppression de VECT_K1
removeMotCle(jdc,"POST_K1_K2_K3","VECT_K1",pasDeRegle(),0)
# Suppression de SYME_CHAR
removeMotCle(jdc,"POST_K1_K2_K3","DTAN_ORIG",pasDeRegle(),0)
removeMotCle(jdc,"POST_K1_K2_K3","DTAN_EXTR",pasDeRegle(),0)
- #### Traitement de POST_K_TRANS ##############################
+ #### traitement de POST_K_TRANS ##############################
# Suppression de la possibilité de donner un mode_meca
GenereErreurMotCleInFact(jdc,"POST_K_TRANS","K_MODAL","RESU_MODA")
- #### Traitement de POST_MAC3COEUR ##############################
+ #### traitement de POST_MAC3COEUR ##############################
# Rien à faire, n'existe pas en 10
- #### Traitement de POST_MAIL_XFEM ##############################
+ #### traitement de POST_MAIL_XFEM ##############################
# Suppression du mot-clé MAILLAGE_SAIN
removeMotCle(jdc,"POST_MAIL_XFEM","MAILLAGE_SAIN",pasDeRegle(),0)
- #### Traitement de POST_RCCM ##############################
+ #### traitement de POST_RCCM ##############################
# Rien à faire
- #### Traitement de POST_RELEVE_T ##############################
+ #### traitement de POST_RELEVE_T ##############################
# Résorption de la sensibilité
removeMotCle(jdc,"POST_RELEVE_T","SENSIBILITE",pasDeRegle(),0)
- #### Traitement de POST_RUPTURE ##############################
+ #### traitement de POST_RUPTURE ##############################
# Rien à faire, n'existe pas en 10
- #### Traitement de POST_USURE ##############################
+ #### traitement de POST_USURE ##############################
# Rien à faire
- #### Traitement de POURSUITE ##############################
+ #### traitement de POURSUITE ##############################
# Suppression du mot-clé TITRE
removeMotCleInFact(jdc,"POURSUITE","CATALOGUE","TITRE",pasDeRegle(),0)
removeMotCle(jdc,"POURSUITE","IMPRESSION",pasDeRegle(),0)
removeMotCleInFact(jdc,"POURSUITE","MEMOIRE","PARTITION",pasDeRegle(),0)
removeMotCleInFact(jdc,"POURSUITE","MEMOIRE","DYNAMIQUE",pasDeRegle(),0)
- #### Traitement de PROJ_BASE ##############################
+ #### traitement de PROJ_BASE ##############################
# Suppression de RESU_GENE pour défaut de validation
GenereErreurMCF(jdc,"PROJ_BASE","RESU_GENE")
- #### Traitement de PROJ_CHAMP ##############################
+ #### traitement de PROJ_CHAMP ##############################
# Résorption de la sensibilité
removeMotCle(jdc,"PROJ_CHAMP","SENSIBILITE",pasDeRegle(),0)
- #### Traitement de PROJ_RESU_BASE ##############################
+ #### traitement de PROJ_RESU_BASE ##############################
# Suppression de RESU_GENE pour défaut de validation
GenereErreurMCF(jdc,"PROJ_RESU_BASE","RESU_GENE")
- #### Traitement de PROJ_SPEC_BASE ##############################
+ #### traitement de PROJ_SPEC_BASE ##############################
# Rien à faire
- #### Traitement de PROPA_FISS ##############################
+ #### traitement de PROPA_FISS ##############################
# Suppression de DTAN_ORIG et DTAN_EXTR pour calcul automatique
removeMotCleInFact(jdc,"PROPA_FISS","FISSURE","DTAN_ORIG",pasDeRegle(),0)
removeMotCleInFact(jdc,"PROPA_FISS","FISSURE","DTAN_EXTR",pasDeRegle(),0)
- #### Traitement de PROPA_XFEM ##############################
+ #### traitement de PROPA_XFEM ##############################
# Suppression paramètres Loi de Paris
removeMotCle(jdc,"PROPA_XFEM","NB_POINT_FOND",pasDeRegle(),0)
removeMotCle(jdc,"PROPA_XFEM","TABLE",pasDeRegle(),0)
removeMotCle(jdc,"PROPA_XFEM","LOI_PROPA",pasDeRegle(),0)
removeMotCle(jdc,"PROPA_XFEM","COMP_LINE",pasDeRegle(),0)
- #### Traitement de RAFF_XFEM ##############################
+ #### traitement de RAFF_XFEM ##############################
# Rien à faire
- #### Traitement de RECU_FONCTION ##############################
+ #### traitement de RECU_FONCTION ##############################
# Résorption de la sensibilité
removeMotCle(jdc,"RECU_FONCTION","SENSIBILITE",pasDeRegle(),0)
# Renommage critere table
dCRIT={"ABS_MAXI":"MAXI_ABS","ABS_MINI":"MINI_ABS"}
ChangementValeurDsMCF(jdc,"RECU_FONCTION","FILTRE","CRIT_COMP",dCRIT)
- #### Traitement de RECU_GENE ##############################
+ #### traitement de RECU_GENE ##############################
# Rien à faire
- #### Traitement de RESOUDRE ##############################
+ #### traitement de RESOUDRE ##############################
# Suppression d'algo pour PETSc
removeMotCleSiRegle(jdc,"RESOUDRE","ALGORITHME",((("BCGS","BICG","TFQMR",),"MCaPourValeur"),))
- #### Traitement de REST_SPEC_PHYS ##############################
+ #### traitement de REST_SPEC_PHYS ##############################
# Rien à faire
- #### Traitement de SIMU_POINT_MAT ##############################
+ #### traitement de SIMU_POINT_MAT ##############################
# VALE_REF obligatoire si NOM_VARC in ('TEMP', 'SECH')
lNOMVARC=["CORR","IRRA","HYDR","EPSA","M_ACIER","M_ZIRC","NEUT1","NEUT2"]
removeMotCleInFactSiRegle(jdc,"SIMU_POINT_MAT","AFFE_VARC","VALE_REF",((("NOM_VARC",lNOMVARC,jdc),"MCsousMCFcourantaPourValeurDansListe"),))
# Suppression de ARCHIVAGE/DETR_NUME_SUIV
removeMotCleInFact(jdc,"SIMU_POINT_MAT","ARCHIVAGE","DETR_NUME_SUIV",pasDeRegle(),0)
- #### Traitement de STANLEY ##############################
+ #### traitement de STANLEY ##############################
# Rien à faire
- #### Traitement de STAT_NON_LINE ##############################
+ #### traitement de STAT_NON_LINE ##############################
# Renommage de IMPLEX
ChangementValeur(jdc,"STAT_NON_LINE","METHODE",{"IMPL_EX":"IMPLEX"})
removeMotCle(jdc,"STAT_NON_LINE","IMPL_EX",pasDeRegle(),0)
# Suppression de ARCHIVAGE/DETR_NUME_SUIV
removeMotCleInFact(jdc,"STAT_NON_LINE","ARCHIVAGE","DETR_NUME_SUIV",pasDeRegle(),0)
- #### Traitement de THER_LINEAIRE ##############################
+ #### traitement de THER_LINEAIRE ##############################
# Résorption de la sensibilité
removeMotCle(jdc,"THER_LINEAIRE","SENSIBILITE",pasDeRegle(),0)
removeMotCle(jdc,"THER_LINEAIRE","SENS_INIT",pasDeRegle(),0)
# Suppression de ARCHIVAGE/DETR_NUME_SUIV
removeMotCleInFact(jdc,"THER_LINEAIRE","ARCHIVAGE","DETR_NUME_SUIV",pasDeRegle(),0)
- #### Traitement de THER_NON_LINE ##############################
+ #### traitement de THER_NON_LINE ##############################
# Résorption de la sensibilité
removeMotCle(jdc,"THER_NON_LINE","SENSIBILITE",pasDeRegle(),0)
# Suppression du mot clé OPTION ######################################
# Suppression de ARCHIVAGE/DETR_NUME_SUIV
removeMotCleInFact(jdc,"THER_NON_LINE","ARCHIVAGE","DETR_NUME_SUIV",pasDeRegle(),0)
- #### Traitement de THER_NON_LINE_MO ##############################
+ #### traitement de THER_NON_LINE_MO ##############################
# Rien à faire
#################################################################
#Parse les mocles des commandes
parseKeywords(root)
- #### Traitement de DEFI_PART_PA_OPS ##############################
+ #### traitement de DEFI_PART_PA_OPS ##############################
GenereErreurPourCommande(jdc,"DEFI_PART_PA_OPS")
- #### Traitement de AFFE_CARA_ELEM ##############################
+ #### traitement de AFFE_CARA_ELEM ##############################
ChangementValeurDsMCFSiRegle(jdc,"AFFE_CARA_ELEM","POUTRE","CARA",{"R1":"R_DEBUT","R2":"R_FIN",
"EP1":"EP_DEBUT","EP2":"EP_FIN"},
((("POUTRE","MAILLE",),"nexistepasMCsousMCF"),
),
)
- #### Traitement de AFFE_CHAR_MECA ##############################
+ #### traitement de AFFE_CHAR_MECA ##############################
# Suppression du mot-clé METHODE
removeMotCle(jdc,"AFFE_CHAR_MECA","METHODE",pasDeRegle(),0)
# Suppression des mot-clés LIAISON_XFEM
removeMotCleInFact(jdc,"AFFE_CHAR_MECA","LIAISON_SOLIDE","ANGL_NAUT",pasDeRegle(),0)
removeMotCleInFact(jdc,"AFFE_CHAR_MECA","LIAISON_SOLIDE","CENTRE",pasDeRegle(),0)
- #### Traitement de AFFE_CHAR_MECA_F ##############################
+ #### traitement de AFFE_CHAR_MECA_F ##############################
# Suppression du mot-clé METHODE
removeMotCle(jdc,"AFFE_CHAR_MECA_F","METHODE",pasDeRegle(),0)
# Résorption des mot-clés ANGLE_NAUT et CENTRE
GenereErreurMotCleInFact(jdc,"AFFE_CHAR_MECA_F","ONDE_PLANE","DIRECTION")
- #### Traitement de AFFE_CHAR_THER ##############################
+ #### traitement de AFFE_CHAR_THER ##############################
# Suppression du mot-clé METHODE
removeMotCle(jdc,"AFFE_CHAR_THER","METHODE",pasDeRegle(),0)
- #### Traitement de AFFE_MODELE ##############################
+ #### traitement de AFFE_MODELE ##############################
# Suppression des mot-clés GRILLE et VERIF
removeMotCle(jdc,"AFFE_MODELE","GRILLE",pasDeRegle(),0)
removeMotCle(jdc,"AFFE_MODELE","VERIF",pasDeRegle(),0)
dINCO.update(dDPLAN)
ChangementValeurDsMCF(jdc,"AFFE_MODELE","AFFE","MODELISATION",dINCO)
- #### Traitement de ASSEMBLAGE ##############################
+ #### traitement de ASSEMBLAGE ##############################
GenereErreurValeurDsMCF(jdc,"ASSEMBLAGE","MATR_ASSE","OPTION",("'MASS_THER'",))
- #### Traitement de CALC_ESSAI_GEOMECA ##############################
+ #### traitement de CALC_ESSAI_GEOMECA ##############################
renameMotCleInFact(jdc,"CALC_ESSAI_GEOMECA","ESSAI_CISA_C","EPSI_IMPOSE","GAMMA_IMPOSE",pasDeRegle(),0)
renameMotCleInFact(jdc,"CALC_ESSAI_GEOMECA","ESSAI_CISA_C","EPSI_ELAS","GAMMA_ELAS",pasDeRegle(),0)
- #### Traitement de CALC_EUROPLEXUS ##############################
+ #### traitement de CALC_EUROPLEXUS ##############################
removeMotCle(jdc,"CALC_EUROPLEXUS","DIME",pasDeRegle(),0)
GenereErreurMCF(jdc,"CALC_EUROPLEXUS","FONC_PARASOL")
removeMotCleInFact(jdc,"CALC_EUROPLEXUS","ARCHIVAGE","CONT_GENER")
- #### Traitement de CALC_FERRAILLAGE ##############################
+ #### traitement de CALC_FERRAILLAGE ##############################
GenereErreurPourCommande(jdc,"CALC_FERRAILLAGE")
- #### Traitement de CALC_FONCTION ##############################
+ #### traitement de CALC_FONCTION ##############################
AjouteMotClefDansFacteur(jdc,"CALC_FONCTION","CORR_ACCE","METHODE='POLYNOME'",pasDeRegle(),0)
GenereErreurMotCleInFact(jdc,"CALC_FONCTION","DSP","FREQ")
- #### Traitement de CALC_G ##############################
+ #### traitement de CALC_G ##############################
removeMotCleInFact(jdc,"CALC_G","COMP_ELAS","RESI_INTE_RELA",pasDeRegle(),0)
removeMotCleInFact(jdc,"CALC_G","COMP_ELAS","ITER_INTE_MAXI",pasDeRegle(),0)
- #### Traitement de CALC_FATIGUE ##############################
+ #### traitement de CALC_FATIGUE ##############################
ChangementValeur(jdc,"CALC_FATIGUE","COURBE_GRD_VIE",{"MANSON_C":"MANSON_COFFIN",})
- #### Traitement de CALC_IFS_DNL ##############################
+ #### traitement de CALC_IFS_DNL ##############################
removeMotCle(jdc,"CALC_IFS_DNL","ENERGIE",pasDeRegle(),0)
- #### Traitement de CALC_MAC3COEUR ##############################
+ #### traitement de CALC_MAC3COEUR ##############################
AjouteMotClefDansFacteur(jdc,"CALC_MAC3COEUR","DEFORMATION","ARCHIMEDE = 'OUI'",pasDeRegle())
- #### Traitement de CALC_MATR_ELEM ##############################
+ #### traitement de CALC_MATR_ELEM ##############################
GenereErreurValeur(jdc,"CALC_MATR_ELEM","OPTION",("'MASS_THER'",))
- #### Traitement de CALC_MISS ##############################
+ #### traitement de CALC_MISS ##############################
GenereErreurValeurDsMCF(jdc,"CALC_MISS","PARAMETRE","ISSF",("'OUI'",))
- #### Traitement de CALC_MODAL ##############################
+ #### traitement de CALC_MODAL ##############################
# renameCommande(jdc,"CALC_MODAL","CALC_MODES", )
GenereErreurPourCommande(jdc,"CALC_MODAL")
- #### Traitement de CALC_VECT_ELEM ##############################
+ #### traitement de CALC_VECT_ELEM ##############################
GenereErreurValeur(jdc,"CALC_VECT_ELEM","OPTION",("'FORC_NODA'",))
- #### Traitement de CREA_MAILLAGE ##############################
+ #### traitement de CREA_MAILLAGE ##############################
renameMotCle(jdc,"CREA_MAILLAGE","CREA_GROUP_MA","CREA_MAILLE")
GenereErreurMCF(jdc,"CREA_MAILLAGE","ECLA_PG")
renameMotCleInFactSiRegle(jdc,"CREA_MAILLAGE","DETR_GROUP_MA","GROUP_MA","NOM",((lMCLEF,"nexistepasMCFParmi"),))
renameCommandeSiRegle(jdc,"CREA_MAILLAGE","DEFI_GROUP",((lMCLEF,"nexistepasMCFParmi"),))
- #### Traitement de DEBUT ##############################
+ #### traitement de DEBUT ##############################
# GenereErreurPourCommande(jdc,("DEBUT",))
removeMotCleInFact(jdc,"DEBUT","CODE","NOM",pasDeRegle(),0)
- #### Traitement de DEFI_COMPOR ##############################
+ #### traitement de DEFI_COMPOR ##############################
GenereErreurValeur(jdc,"DEFI_COMPOR","LOCALISATION",["'RL'",])
GenereErreurValeur(jdc,"DEFI_COMPOR","RELATION_KIT",["'RVMIS_ISOT_CINE'",])
GenereErreurValeurDsMCF(jdc,"DEFI_COMPOR","MULTIFIBRE","RELATION",["'LABORD_1D'"])
GenereErreurMCF(jdc,"DEFI_COMPOR","POLYCRISTAL")
- #### Traitement de DEFI_FISS_XFEM ##############################
+ #### traitement de DEFI_FISS_XFEM ##############################
GenereErreurPourCommande(jdc,("DEFI_FISS_XFEM",))
removeMotCle(jdc,"DEFI_FISS_XFEM","MODELE",pasDeRegle(),0)
removeMotCle(jdc,"DEFI_FISS_XFEM","MODELE_GRILLE",pasDeRegle(),0)
- #### Traitement de DEFI_LIST_INST ##############################
+ #### traitement de DEFI_LIST_INST ##############################
ChangementValeurDsMCF(jdc,"DEFI_LIST_INST","ECHEC","ACTION",{"REAC_PRECOND":"DECOUPE"})
- #### Traitement de DEFI_MATER_GC ##############################
+ #### traitement de DEFI_MATER_GC ##############################
AjouteMotClefDansFacteur(jdc,"DEFI_MATER_GC","MAZARS","CODIFICATION='ESSAI'",pasDeRegle(),0)
removeMotCleInFactSiRegle(jdc,"DEFI_MATER_GC","MAZARS","UNITE_LONGUEUR",
GenereErreurMCF(jdc,"DEFI_MATER_GC","MAZARS")
- #### Traitement de DEFI_MATERIAU ##############################
+ #### traitement de DEFI_MATERIAU ##############################
lMLA=["F_MRR_RR", "C_MRR_RR", "F_MTT_TT", "C_MTT_TT", "F_MZZ_ZZ",
"C_MZZ_ZZ", "F_MRT_RT", "C_MRT_RT", "F_MRZ_RZ", "C_MRZ_RZ",
"F_MTZ_TZ", "C_MTZ_TZ",]
GenereErreurMCF(jdc,"DEFI_MATERIAU","THER_COQUE_FO")
- #### Traitement de DEFI_OBSTACLE ##############################
+ #### traitement de DEFI_OBSTACLE ##############################
lMCLE=("CRAYON_900","CRAYON_1300","GUID_A_CARTE_900",
"GUID_B_CARTE_900","GUID_C_CARTE_900","GUID_D_CARTE_900","GUID_E_CARTE_900",
"GUID_F_CARTE_900","GUID_A_CARTE_1300","GUID_B_CARTE_1300","GUID_C_CARTE_1300",
"GUID_D_GCOMB_1300","GUID_E_GCOMB_1300","GUID_F_GCOMB_1300",)
GenereErreurValeur(jdc,"DEFI_OBSTACLE","TYPE",lMCLE)
- #### Traitement de DYNA_TRAN_MODAL ##############################
+ #### traitement de DYNA_TRAN_MODAL ##############################
removeMotCle(jdc,"DYNA_TRAN_MODAL","LAME_FLUIDE",pasDeRegle(),0)
removeMotCle(jdc,"DYNA_TRAN_MODAL","PARA_LAME_FLUI",pasDeRegle(),0)
removeMotCle(jdc,"DYNA_TRAN_MODAL","RELA_TRANSIS",pasDeRegle(),0)
- #### Traitement de DYNA_VIBRA ##############################
+ #### traitement de DYNA_VIBRA ##############################
removeMotCle(jdc,"DYNA_VIBRA","LAME_FLUIDE",pasDeRegle(),0)
removeMotCle(jdc,"DYNA_VIBRA","PARA_LAME_FLUI",pasDeRegle(),0)
removeMotCle(jdc,"DYNA_VIBRA","RELA_TRANSIS",pasDeRegle(),0)
- #### Traitement de EXTR_TABLE ##############################
+ #### traitement de EXTR_TABLE ##############################
ChangementValeurDsMCF(jdc,"EXTR_TABLE","FILTRE","VALE_K",{"MATR_ELEM":"MATR_TANG_ELEM"})
ChangementValeurDsMCF(jdc,"EXTR_TABLE","FILTRE","VALE_K",{"CODE_RETOUR":"CODE_RETOUR_INTE"})
- #### Traitement de FACTORISER ##############################
+ #### traitement de FACTORISER ##############################
renameMotCle(jdc,"FACTORISER","ELIM_LAGR2","ELIM_LAGR")
ChangementValeur(jdc,"FACTORISER","ELIM_LAGR",{"OUI":"LAGR2",})
- #### Traitement de GENE_ACCE_SEISME ##############################
+ #### traitement de GENE_ACCE_SEISME ##############################
GenereErreurMCF(jdc,"GENE_ACCE_SEISME","MODULATION")
moveMotCleFromFactToFather(jdc,"GENE_ACCE_SEISME","MODULATION","DUREE_PHASE_FORTE")
removeMotCleInFact(jdc,"GENE_ACCE_SEISME","DSP","FREQ_PENTE")
- #### Traitement de IMPR_MISS_3D ##############################
+ #### traitement de IMPR_MISS_3D ##############################
GenereErreurPourCommande(jdc,"IMPR_MISS_3D")
# removeCommande(jdc,"IMPR_MISS_3D")
- #### Traitement de IMPR_RESU ##############################
+ #### traitement de IMPR_RESU ##############################
removeMotCle(jdc,"IMPR_RESU","RESTREINT",pasDeRegle(),0)
- #### Traitement de INFO_FONCTION ##############################
+ #### traitement de INFO_FONCTION ##############################
GenereErreurMCF(jdc,"INFO_FONCTION","NOCI_SEISME")
- #### Traitement de LIRE_MAILLAGE ##############################
+ #### traitement de LIRE_MAILLAGE ##############################
removeMotCle(jdc,"LIRE_MAILLAGE","ABSC_CURV",pasDeRegle(),0)
- #### Traitement de LIRE_MISS_3D ##############################
+ #### traitement de LIRE_MISS_3D ##############################
GenereErreurPourCommande(jdc,"LIRE_MISS_3D")
- #### Traitement de MACR_ASCOUF_CALC ##############################
+ #### traitement de MACR_ASCOUF_CALC ##############################
removeMotCle(jdc,"MACR_ASCOUF_CALC","CL_BOL_P2_GV",pasDeRegle(),0)
# GenereErreurMCF(jdc,"MACR_ASCOUF_CALC","COMP_ELAS")
- #### Traitement de MACR_ASCOUF_MAIL ##############################
+ #### traitement de MACR_ASCOUF_MAIL ##############################
GenereErreurValeurDsMCF(jdc,"MACR_ASCOUF_MAIL","COUDE","BOL_P2",("'GV'",))
- #### Traitement de MACR_ASPIC_CALC ##############################
+ #### traitement de MACR_ASPIC_CALC ##############################
# GenereErreurMCF(jdc,"MACR_ASPIC_CALC","COMP_ELAS")
- #### Traitement de MACR_ECREVISSE ##############################
+ #### traitement de MACR_ECREVISSE ##############################
GenereErreurMCF(jdc,"MACR_ECREVISSE","COMP_INCR")
- #### Traitement de MACR_INFO_MAIL ##############################
+ #### traitement de MACR_INFO_MAIL ##############################
ChangementValeur(jdc,"MACR_INFO_MAIL","VERSION_HOMARD",{"V10_6":"V11_2"})
ChangementValeur(jdc,"MACR_INFO_MAIL","VERSION_HOMARD",{"V10_N":"V11_N"})
ChangementValeur(jdc,"MACR_INFO_MAIL","VERSION_HOMARD",{"V10_N_PERSO":"V11_N_PERSO"})
- #### Traitement de MACRO_BASCULE_SCHEMA ##############################
+ #### traitement de MACRO_BASCULE_SCHEMA ##############################
renameMotCle(jdc,"MACRO_BASCULE_SCHEMA","COMP_INCR_IMPL","COMPORTEMENT_IMPL",pasDeRegle())
renameMotCle(jdc,"MACRO_BASCULE_SCHEMA","COMP_INCR_EXPL","COMPORTEMENT_EXPL",pasDeRegle())
- #### Traitement de MACRO_MISS_3D ##############################
+ #### traitement de MACRO_MISS_3D ##############################
GenereErreurPourCommande(jdc,"MACRO_MISS_3D")
- #### Traitement de MACRO_MODE_MECA ##############################
+ #### traitement de MACRO_MODE_MECA ##############################
# insereMotCleDansCommande(jdc,"MACRO_MODE_MECA","TYPE_RESU='DYNAMIQUE'")
chercheOperInsereFacteur(jdc,"MACRO_MODE_MECA","SOLVEUR_MODAL",)
chercheOperInsereFacteur(jdc,"MACRO_MODE_MECA","OPTION='BANDE'",pasDeRegle(),0)
moveMotCleFromFactToFact(jdc,"MACRO_MODE_MECA","CALC_FREQ","DIM_SOUS_ESPACE","SOLVEUR_MODAL")
renameCommande(jdc,"MACRO_MODE_MECA","CALC_MODES", )
- #### Traitement de MODE_ITER_INV ##############################
+ #### traitement de MODE_ITER_INV ##############################
chercheOperInsereFacteur(jdc,"MODE_ITER_INV","SOLVEUR_MODAL",)
moveMotCleFromFactToFather(jdc,"MODE_ITER_INV","CALC_FREQ","OPTION")
moveMotCleFromFactToFather(jdc,"MODE_ITER_INV","CALC_CHAR_CRIT","OPTION")
renameCommande(jdc,"MODE_ITER_INV","CALC_MODES", )
- #### Traitement de MODE_ITER_SIMULT ##############################
+ #### traitement de MODE_ITER_SIMULT ##############################
chercheOperInsereFacteur(jdc,"MODE_ITER_SIMULT","SOLVEUR_MODAL",)
removeMotCleSiRegle(jdc,"MODE_ITER_SIMULT","OPTION",((("METHODE","TRI_DIAG",jdc),"MCnaPasPourValeur"),),)
removeMotCleSiRegle(jdc,"MODE_ITER_SIMULT","OPTION",((("OPTION","SANS",jdc),"MCaPourValeur"),),)
renameCommande(jdc,"MODE_ITER_SIMULT","CALC_MODES", )
- #### Traitement de MODI_MAILLAGE ##############################
+ #### traitement de MODI_MAILLAGE ##############################
GenereErreurValeurDsMCF(jdc,"MODI_MAILLAGE","DEFORME","OPTION",("'TRAN_APPUI'",))
removeMotCleInFact(jdc,"MODI_MAILLAGE","DEFORME",["GROUP_NO_APPUI"],pasDeRegle(),0)
removeMotCleInFact(jdc,"MODI_MAILLAGE","DEFORME",["GROUP_NO_STRU"],pasDeRegle(),0)
- #### Traitement de MODI_MODELE_XFEM ##############################
+ #### traitement de MODI_MODELE_XFEM ##############################
ChangementValeur(jdc,"MODI_MODELE_XFEM","CONTACT",{"P1P1":"STANDARD",})
ChangementValeur(jdc,"MODI_MODELE_XFEM","CONTACT",{"P2P1":"STANDARD",})
- #### Traitement de POST_DYNA_ALEA ##############################
+ #### traitement de POST_DYNA_ALEA ##############################
chercheOperInsereFacteurSiRegle(jdc,"POST_DYNA_ALEA","INTERSPECTRE",((("INTE_SPEC",),"existe"),),1)
lPDA=["INTE_SPEC", "NUME_ORDRE_I", "NOEUD_I", "OPTION", "NUME_ORDRE_J",
"NOEUD_J", "NOM_CMP_I", "NOM_CMP_J", "MOMENT", "DUREE"]
AjouteMotClefDansFacteur(jdc,"POST_DYNA_ALEA","FRAGILITE","METHODE = 'EMV'",pasDeRegle())
- #### Traitement de POST_ELEM ##############################
+ #### traitement de POST_ELEM ##############################
AjouteMotClefDansFacteurSiRegle(jdc,"POST_ELEM","VOLUMOGRAMME","NB_INTERV=5",
((("VOLUMOGRAMME","NB_INTERV",),"nexistepasMCsousMCF"),),)
- #### Traitement de POST_FATIGUE ##############################
+ #### traitement de POST_FATIGUE ##############################
ChangementValeur(jdc,"POST_FATIGUE","DOMMAGE",{"MANSON_C":"MANSON_COFFIN",})
- #### Traitement de POURSUITE ##############################
+ #### traitement de POURSUITE ##############################
removeMotCle(jdc,"POURSUITE","CODE",)#"NOM",pasDeRegle(),0)
- #### Traitement de RECU_FONCTION ##############################
+ #### traitement de RECU_FONCTION ##############################
GenereErreurMCF(jdc,"RECU_FONCTION","TABLE")
- #### Traitement de C_COMP_INCR et C_COMP_ELAS ##############################
+ #### traitement de C_COMP_INCR et C_COMP_ELAS ##############################
lCOM=["CALCUL","STAT_NON_LINE","CALC_G", "CALC_PRECONT","DYNA_NON_LINE","CALC_META",
"TEST_COMPOR","SIMU_POINT_MAT","CALC_ESSAI_GEOMECA","CALC_FORC_NONL","LIRE_RESU",
"MACR_ASCOUF_CALC","MACR_ASPIC_CALC","CALC_EUROPLEXUS","MACR_ECREVISSE",]
removeMotCleInFactSiRegle(jdc,com,"COMPORTEMENT","NB_VARI",((("COMPORTEMENT","RELATION","'MFRONT'",jdc),"MCsousMCFaPourValeur"),))
- #### Traitement de TEST_COMPOR ##############################
+ #### traitement de TEST_COMPOR ##############################
GenereErreurPourCommande(jdc,"TEST_COMPOR")
- #### Traitement de THER_NON_LINE ##############################
+ #### traitement de THER_NON_LINE ##############################
renameMotCle(jdc,"THER_NON_LINE","COMP_THER_NL","COMPORTEMENT")
- #### Traitement de C_SOLVEUR ##############################
+ #### traitement de C_SOLVEUR ##############################
lCOM=['CALC_ERREUR', 'CALC_FORC_AJOU', 'CALC_IFS_DNL', 'CALC_MATR_AJOU', 'CALC_PRECONT',
'CREA_ELEM_SSD', 'DEFI_BASE_MODALE', 'DYNA_LINE_HARM', 'DYNA_LINE_TRAN', 'DYNA_NON_LINE',
'DYNA_TRAN_MODAL', 'INFO_MODE', 'MACR_ASCOUF_CALC', 'MACR_ASPIC_CALC', 'MACRO_BASCULE_SCHEMA',
for mocle in lMCLE:
GenereErreurMotCleInFact(jdc,com,"SOLVEUR",mocle)
- #### Traitement de DEFI_PART_FETI ##############################
+ #### traitement de DEFI_PART_FETI ##############################
GenereErreurMCF(jdc,"DEFI_PART_FETI","EXCIT")
removeMotCle(jdc,"DEFI_PART_FETI","EXCIT",pasDeRegle(),0)
removeMotCle(jdc,"DEFI_PART_FETI","CORRECTION_CONNEX",pasDeRegle(),0)
# non fait CALC_NO OPTION=FORC_NODA_NONL
- ########## Traitement MACRO_MISS_3D --> CALC_MISS
+ ########## traitement MACRO_MISS_3D --> CALC_MISS
renameCommandeSiRegle(jdc,"MACRO_MISS_3D","CALC_MISS",((("OPTION","MODULE","MISS_IMPE",jdc),"MCsousMCFaPourValeur"),(("PARAMETRE","ISSF"),"nexistepasMCsousMCF"),(("PARAMETRE","DIRE_ONDE"),"nexistepasMCsousMCF"),(("PARAMETRE","CONTR_LISTE"),"nexistepasMCsousMCF"),(("PARAMETRE","CONTR_NB"),"nexistepasMCsousMCF"),))
renameCommandeSiRegle(jdc,"MACRO_MISS_3D","CALC_MISS",((("OPTION","MODULE","MISS_IMPE",jdc),"MCsousMCFaPourValeur"),(("PARAMETRE","ISSF","NON",jdc),"MCsousMCFaPourValeur"),(("PARAMETRE","DIRE_ONDE"),"nexistepasMCsousMCF"),(("PARAMETRE","CONTR_LISTE"),"nexistepasMCsousMCF"),(("PARAMETRE","CONTR_NB"),"nexistepasMCsousMCF"),))
removeMotCleInFact(jdc,"CALC_MISS","PARAMETRE","FICH_RESU_IMPE",pasDeRegle(),0)
<?xml version="1.0" encoding="UTF-8"?>
<ui version="4.0">
<class>ChoixCode</class>
- <widget class="QWidget" name="ChoixCode">
+ <widget class="QDialog" name="ChoixCode">
<property name="geometry">
<rect>
<x>0</x>
<y>0</y>
- <width>555</width>
- <height>332</height>
+ <width>205</width>
+ <height>96</height>
</rect>
</property>
- <property name="sizePolicy">
- <sizepolicy hsizetype="Preferred" vsizetype="MinimumExpanding">
- <horstretch>0</horstretch>
- <verstretch>0</verstretch>
- </sizepolicy>
- </property>
<property name="windowTitle">
- <string>Choix du code</string>
+ <string>Coix du Code</string>
</property>
<layout class="QVBoxLayout" name="verticalLayout">
- <item>
- <widget class="QLabel" name="label_choix">
- <property name="sizePolicy">
- <sizepolicy hsizetype="Preferred" vsizetype="Fixed">
- <horstretch>0</horstretch>
- <verstretch>0</verstretch>
- </sizepolicy>
- </property>
- <property name="minimumSize">
- <size>
- <width>0</width>
- <height>30</height>
- </size>
- </property>
- <property name="text">
- <string>Veuillez choisir un code :</string>
- </property>
- </widget>
- </item>
+ <property name="spacing">
+ <number>0</number>
+ </property>
+ <property name="leftMargin">
+ <number>0</number>
+ </property>
+ <property name="topMargin">
+ <number>0</number>
+ </property>
+ <property name="rightMargin">
+ <number>0</number>
+ </property>
+ <property name="bottomMargin">
+ <number>0</number>
+ </property>
<item>
<widget class="QGroupBox" name="groupBox">
<property name="sizePolicy">
- <sizepolicy hsizetype="Preferred" vsizetype="MinimumExpanding">
+ <sizepolicy hsizetype="Preferred" vsizetype="Expanding">
<horstretch>0</horstretch>
<verstretch>0</verstretch>
</sizepolicy>
<string/>
</property>
<layout class="QVBoxLayout" name="vlBouton">
+ <property name="leftMargin">
+ <number>0</number>
+ </property>
+ <property name="topMargin">
+ <number>0</number>
+ </property>
+ <property name="rightMargin">
+ <number>0</number>
+ </property>
+ <property name="bottomMargin">
+ <number>0</number>
+ </property>
<item>
- <spacer name="verticalSpacer">
+ <spacer name="verticalSpacer_2">
<property name="orientation">
<enum>Qt::Vertical</enum>
</property>
<property name="sizeHint" stdset="0">
<size>
<width>20</width>
- <height>40</height>
+ <height>20</height>
</size>
</property>
</spacer>
</widget>
</item>
<item>
- <layout class="QHBoxLayout" name="horizontalLayout">
- <property name="sizeConstraint">
- <enum>QLayout::SetFixedSize</enum>
+ <widget class="QDialogButtonBox" name="buttonBox">
+ <property name="orientation">
+ <enum>Qt::Horizontal</enum>
+ </property>
+ <property name="standardButtons">
+ <set>QDialogButtonBox::Cancel|QDialogButtonBox::Ok</set>
</property>
- <item>
- <spacer name="horizontalSpacer_4">
- <property name="orientation">
- <enum>Qt::Horizontal</enum>
- </property>
- <property name="sizeHint" stdset="0">
- <size>
- <width>40</width>
- <height>20</height>
- </size>
- </property>
- </spacer>
- </item>
- <item>
- <widget class="QPushButton" name="pB_cancel">
- <property name="minimumSize">
- <size>
- <width>140</width>
- <height>40</height>
- </size>
- </property>
- <property name="toolTip">
- <string/>
- </property>
- <property name="styleSheet">
- <string notr="true">background-color:rgb(104,110,149);
-color :white;
-border-radius : 12px
-</string>
- </property>
- <property name="text">
- <string>&Cancel</string>
- </property>
- <property name="shortcut">
- <string/>
- </property>
- <property name="autoDefault">
- <bool>true</bool>
- </property>
- </widget>
- </item>
- <item>
- <spacer name="horizontalSpacer">
- <property name="orientation">
- <enum>Qt::Horizontal</enum>
- </property>
- <property name="sizeType">
- <enum>QSizePolicy::Fixed</enum>
- </property>
- <property name="sizeHint" stdset="0">
- <size>
- <width>40</width>
- <height>20</height>
- </size>
- </property>
- </spacer>
- </item>
- <item>
- <widget class="QPushButton" name="pB_OK">
- <property name="minimumSize">
- <size>
- <width>140</width>
- <height>40</height>
- </size>
- </property>
- <property name="toolTip">
- <string>Validate choice</string>
- </property>
- <property name="styleSheet">
- <string notr="true">background-color:rgb(104,110,149);
-color :white;
-border-radius : 12px
-
-</string>
- </property>
- <property name="text">
- <string>&OK</string>
- </property>
- <property name="shortcut">
- <string/>
- </property>
- <property name="autoDefault">
- <bool>true</bool>
- </property>
- <property name="default">
- <bool>true</bool>
- </property>
- </widget>
- </item>
- </layout>
+ </widget>
</item>
</layout>
</widget>
<resources/>
- <connections/>
+ <connections>
+ <connection>
+ <sender>buttonBox</sender>
+ <signal>accepted()</signal>
+ <receiver>ChoixCode</receiver>
+ <slot>accept()</slot>
+ <hints>
+ <hint type="sourcelabel">
+ <x>248</x>
+ <y>254</y>
+ </hint>
+ <hint type="destinationlabel">
+ <x>157</x>
+ <y>274</y>
+ </hint>
+ </hints>
+ </connection>
+ <connection>
+ <sender>buttonBox</sender>
+ <signal>rejected()</signal>
+ <receiver>ChoixCode</receiver>
+ <slot>reject()</slot>
+ <hints>
+ <hint type="sourcelabel">
+ <x>316</x>
+ <y>260</y>
+ </hint>
+ <hint type="destinationlabel">
+ <x>286</x>
+ <y>274</y>
+ </hint>
+ </hints>
+ </connection>
+ </connections>
</ui>
--- /dev/null
+<?xml version="1.0" encoding="UTF-8"?>
+<ui version="4.0">
+ <class>WidgetCBIntoSug</class>
+ <widget class="QWidget" name="WidgetCBIntoSug">
+ <property name="geometry">
+ <rect>
+ <x>0</x>
+ <y>0</y>
+ <width>1104</width>
+ <height>102</height>
+ </rect>
+ </property>
+ <property name="sizePolicy">
+ <sizepolicy hsizetype="Preferred" vsizetype="Minimum">
+ <horstretch>0</horstretch>
+ <verstretch>0</verstretch>
+ </sizepolicy>
+ </property>
+ <property name="minimumSize">
+ <size>
+ <width>0</width>
+ <height>0</height>
+ </size>
+ </property>
+ <property name="maximumSize">
+ <size>
+ <width>1493</width>
+ <height>150</height>
+ </size>
+ </property>
+ <property name="windowTitle">
+ <string>Form</string>
+ </property>
+ <property name="styleSheet">
+ <string notr="true">QComboBox{combobox-popup:0;};</string>
+ </property>
+ <layout class="QHBoxLayout" name="horizontalLayout_3">
+ <property name="spacing">
+ <number>0</number>
+ </property>
+ <property name="leftMargin">
+ <number>0</number>
+ </property>
+ <property name="topMargin">
+ <number>4</number>
+ </property>
+ <property name="rightMargin">
+ <number>0</number>
+ </property>
+ <property name="bottomMargin">
+ <number>9</number>
+ </property>
+ <item>
+ <layout class="QVBoxLayout" name="verticalLayout_2">
+ <property name="spacing">
+ <number>0</number>
+ </property>
+ <item>
+ <layout class="QHBoxLayout" name="horizontalLayout">
+ <property name="spacing">
+ <number>0</number>
+ </property>
+ <property name="sizeConstraint">
+ <enum>QLayout::SetFixedSize</enum>
+ </property>
+ <item>
+ <spacer name="horizontalSpacer_3">
+ <property name="orientation">
+ <enum>Qt::Horizontal</enum>
+ </property>
+ <property name="sizeType">
+ <enum>QSizePolicy::Fixed</enum>
+ </property>
+ <property name="sizeHint" stdset="0">
+ <size>
+ <width>21</width>
+ <height>20</height>
+ </size>
+ </property>
+ </spacer>
+ </item>
+ <item>
+ <widget class="MonBoutonValide" name="RBValide">
+ <property name="minimumSize">
+ <size>
+ <width>21</width>
+ <height>25</height>
+ </size>
+ </property>
+ <property name="maximumSize">
+ <size>
+ <width>21</width>
+ <height>25</height>
+ </size>
+ </property>
+ <property name="focusPolicy">
+ <enum>Qt::ClickFocus</enum>
+ </property>
+ <property name="toolTip">
+ <string>Affiche le rapport de validation du mot-clef</string>
+ </property>
+ <property name="styleSheet">
+ <string notr="true">border : 0px</string>
+ </property>
+ <property name="text">
+ <string>...</string>
+ </property>
+ <property name="icon">
+ <iconset>
+ <normaloff>../Editeur/icons/ast-green-ball.png</normaloff>../Editeur/icons/ast-green-ball.png</iconset>
+ </property>
+ <property name="iconSize">
+ <size>
+ <width>25</width>
+ <height>25</height>
+ </size>
+ </property>
+ </widget>
+ </item>
+ </layout>
+ </item>
+ <item>
+ <spacer name="verticalSpacer">
+ <property name="orientation">
+ <enum>Qt::Vertical</enum>
+ </property>
+ <property name="sizeHint" stdset="0">
+ <size>
+ <width>20</width>
+ <height>5</height>
+ </size>
+ </property>
+ </spacer>
+ </item>
+ </layout>
+ </item>
+ <item>
+ <widget class="MonLabelClic" name="label">
+ <property name="sizePolicy">
+ <sizepolicy hsizetype="Fixed" vsizetype="Preferred">
+ <horstretch>0</horstretch>
+ <verstretch>0</verstretch>
+ </sizepolicy>
+ </property>
+ <property name="minimumSize">
+ <size>
+ <width>300</width>
+ <height>25</height>
+ </size>
+ </property>
+ <property name="maximumSize">
+ <size>
+ <width>178</width>
+ <height>16777215</height>
+ </size>
+ </property>
+ <property name="frameShape">
+ <enum>QFrame::NoFrame</enum>
+ </property>
+ <property name="text">
+ <string><html><head/><body><p>aaa</p><p>dqsklmdqm</p></body></html></string>
+ </property>
+ <property name="scaledContents">
+ <bool>false</bool>
+ </property>
+ <property name="alignment">
+ <set>Qt::AlignLeading|Qt::AlignLeft|Qt::AlignTop</set>
+ </property>
+ </widget>
+ </item>
+ <item>
+ <layout class="QVBoxLayout" name="verticalLayout">
+ <item>
+ <widget class="QFrame" name="frameHorsListe">
+ <property name="styleSheet">
+ <string notr="true">background:rgb(221, 221, 166)</string>
+ </property>
+ <property name="frameShape">
+ <enum>QFrame::Box</enum>
+ </property>
+ <layout class="QVBoxLayout" name="verticalLayout_3">
+ <property name="spacing">
+ <number>0</number>
+ </property>
+ <property name="leftMargin">
+ <number>0</number>
+ </property>
+ <property name="topMargin">
+ <number>0</number>
+ </property>
+ <property name="rightMargin">
+ <number>0</number>
+ </property>
+ <property name="bottomMargin">
+ <number>0</number>
+ </property>
+ <item>
+ <widget class="QLabel" name="label_2">
+ <property name="styleSheet">
+ <string notr="true"/>
+ </property>
+ <property name="text">
+ <string>Valeurs hors liste - la valeur saisie sera ajoutée à la liste</string>
+ </property>
+ </widget>
+ </item>
+ <item>
+ <widget class="QLineEdit" name="lineEditVal">
+ <property name="styleSheet">
+ <string notr="true">background : white
+</string>
+ </property>
+ </widget>
+ </item>
+ </layout>
+ </widget>
+ </item>
+ <item>
+ <layout class="QHBoxLayout" name="horizontalLayout_2">
+ <property name="spacing">
+ <number>0</number>
+ </property>
+ <item>
+ <widget class="QComboBox" name="CBChoix">
+ <property name="sizePolicy">
+ <sizepolicy hsizetype="Preferred" vsizetype="Fixed">
+ <horstretch>0</horstretch>
+ <verstretch>0</verstretch>
+ </sizepolicy>
+ </property>
+ <property name="minimumSize">
+ <size>
+ <width>361</width>
+ <height>32</height>
+ </size>
+ </property>
+ <property name="accessibleName">
+ <string/>
+ </property>
+ <property name="accessibleDescription">
+ <string/>
+ </property>
+ <property name="styleSheet">
+ <string notr="true">QComboBox {
+ background:rgb(235,235,235);
+ }
+/*QComboBox: on {
+ font : italic
+ }
+background:rgb(235,235,235);
+border:0px;
+
+
+QComboBox:!editable:on, QComboBox::drop-down:editable:on {
+background: black;
+ font : italic 14px
+ }
+QComboBox:on {
+ font : italic 20px;
+ background: red ;
+}/*
+</string>
+ </property>
+ <property name="maxVisibleItems">
+ <number>100</number>
+ </property>
+ <property name="frame">
+ <bool>false</bool>
+ </property>
+ </widget>
+ </item>
+ <item>
+ <spacer name="horizontalSpacer">
+ <property name="orientation">
+ <enum>Qt::Horizontal</enum>
+ </property>
+ <property name="sizeType">
+ <enum>QSizePolicy::Expanding</enum>
+ </property>
+ <property name="sizeHint" stdset="0">
+ <size>
+ <width>301</width>
+ <height>20</height>
+ </size>
+ </property>
+ </spacer>
+ </item>
+ <item>
+ <widget class="QToolButton" name="RBPoubelle">
+ <property name="minimumSize">
+ <size>
+ <width>21</width>
+ <height>25</height>
+ </size>
+ </property>
+ <property name="maximumSize">
+ <size>
+ <width>21</width>
+ <height>25</height>
+ </size>
+ </property>
+ <property name="toolTip">
+ <string>Détruit le mot-clef</string>
+ </property>
+ <property name="styleSheet">
+ <string notr="true">border : 0px</string>
+ </property>
+ <property name="text">
+ <string>...</string>
+ </property>
+ <property name="icon">
+ <iconset>
+ <normaloff>../Editeur/icons/deleteRond.png</normaloff>../Editeur/icons/deleteRond.png</iconset>
+ </property>
+ <property name="iconSize">
+ <size>
+ <width>25</width>
+ <height>25</height>
+ </size>
+ </property>
+ </widget>
+ </item>
+ </layout>
+ </item>
+ </layout>
+ </item>
+ </layout>
+ </widget>
+ <customwidgets>
+ <customwidget>
+ <class>MonBoutonValide</class>
+ <extends>QToolButton</extends>
+ <header>monBoutonValide.h</header>
+ </customwidget>
+ <customwidget>
+ <class>MonLabelClic</class>
+ <extends>QLabel</extends>
+ <header>monLabelClic.h</header>
+ </customwidget>
+ </customwidgets>
+ <resources/>
+ <connections/>
+</ui>
<rect>
<x>0</x>
<y>0</y>
- <width>1353</width>
- <height>596</height>
+ <width>1110</width>
+ <height>731</height>
</rect>
</property>
<property name="sizePolicy">
<string notr="true">background-color : rgb(224,223,222);
font : 'times' 9px</string>
</property>
- <layout class="QVBoxLayout" name="verticalLayout_4">
+ <layout class="QVBoxLayout" name="verticalLayout_5">
<property name="spacing">
<number>0</number>
</property>
<property name="minimumSize">
<size>
<width>0</width>
- <height>130</height>
+ <height>8</height>
</size>
</property>
<property name="maximumSize">
<size>
<width>16777215</width>
- <height>130</height>
+ <height>75</height>
</size>
</property>
<property name="styleSheet">
<string notr="true">background-color:rgb(224,223,222)</string>
</property>
- <layout class="QGridLayout" name="gridLayout_2">
- <property name="topMargin">
- <number>2</number>
+ <layout class="QHBoxLayout" name="horizontalLayout_2">
+ <property name="spacing">
+ <number>0</number>
</property>
- <property name="bottomMargin">
- <number>3</number>
+ <property name="margin">
+ <number>0</number>
</property>
- <property name="verticalSpacing">
- <number>2</number>
- </property>
- <item row="0" column="0">
- <widget class="QFrame" name="frame_2">
- <property name="sizePolicy">
- <sizepolicy hsizetype="Preferred" vsizetype="Fixed">
- <horstretch>0</horstretch>
- <verstretch>0</verstretch>
- </sizepolicy>
- </property>
- <property name="frameShape">
- <enum>QFrame::Box</enum>
- </property>
- <property name="frameShadow">
- <enum>QFrame::Raised</enum>
+ <item>
+ <layout class="QVBoxLayout" name="verticalLayout_3">
+ <property name="spacing">
+ <number>0</number>
</property>
- <layout class="QHBoxLayout" name="horizontalLayout">
- <property name="spacing">
- <number>0</number>
- </property>
- <item>
- <spacer name="horizontalSpacer_5">
- <property name="orientation">
- <enum>Qt::Horizontal</enum>
- </property>
- <property name="sizeType">
- <enum>QSizePolicy::Fixed</enum>
- </property>
- <property name="sizeHint" stdset="0">
- <size>
- <width>13</width>
- <height>20</height>
- </size>
- </property>
- </spacer>
- </item>
- <item>
- <widget class="MonBoutonValide" name="RBValide">
- <property name="minimumSize">
- <size>
- <width>17</width>
- <height>31</height>
- </size>
- </property>
- <property name="maximumSize">
- <size>
- <width>21</width>
- <height>31</height>
- </size>
- </property>
- <property name="focusPolicy">
- <enum>Qt::ClickFocus</enum>
- </property>
- <property name="toolTip">
- <string>Affiche le rapport de validité de la commande</string>
- </property>
- <property name="styleSheet">
- <string notr="true">border : 0px</string>
- </property>
- <property name="text">
- <string>...</string>
- </property>
- <property name="icon">
- <iconset>
- <normaloff>../../../.designer/Editeur/icons/ast-green-ball.png</normaloff>../../../.designer/Editeur/icons/ast-green-ball.png</iconset>
- </property>
- <property name="iconSize">
- <size>
- <width>21</width>
- <height>31</height>
- </size>
- </property>
- </widget>
- </item>
- <item>
- <spacer name="horizontalSpacer_3">
- <property name="orientation">
- <enum>Qt::Horizontal</enum>
- </property>
- <property name="sizeType">
- <enum>QSizePolicy::Fixed</enum>
- </property>
- <property name="sizeHint" stdset="0">
- <size>
- <width>13</width>
- <height>20</height>
- </size>
- </property>
- </spacer>
- </item>
- <item>
- <widget class="MonLabelClic" name="labelNomCommande">
- <property name="sizePolicy">
- <sizepolicy hsizetype="MinimumExpanding" vsizetype="Fixed">
- <horstretch>0</horstretch>
- <verstretch>0</verstretch>
- </sizepolicy>
- </property>
- <property name="minimumSize">
- <size>
- <width>150</width>
- <height>31</height>
- </size>
- </property>
- <property name="frameShape">
- <enum>QFrame::NoFrame</enum>
- </property>
- <property name="frameShadow">
- <enum>QFrame::Raised</enum>
- </property>
- <property name="text">
- <string><html><head/><body><p><span style=" color:#0000ff;">commande </span></p></body></html></string>
- </property>
- </widget>
- </item>
- <item>
- <spacer name="toto">
- <property name="orientation">
- <enum>Qt::Horizontal</enum>
- </property>
- <property name="sizeType">
- <enum>QSizePolicy::Maximum</enum>
- </property>
- <property name="sizeHint" stdset="0">
- <size>
- <width>2</width>
- <height>40</height>
- </size>
- </property>
- </spacer>
- </item>
- <item>
- <widget class="QLineEdit" name="LENom">
- <property name="sizePolicy">
- <sizepolicy hsizetype="MinimumExpanding" vsizetype="Preferred">
- <horstretch>0</horstretch>
- <verstretch>0</verstretch>
- </sizepolicy>
- </property>
- <property name="toolTip">
- <string>Nom de l'objet. Seuls, les objets valides peuvent être nommés</string>
- </property>
- <property name="styleSheet">
- <string notr="true"> QLineEdit {
+ <item>
+ <layout class="QHBoxLayout" name="horizontalLayout">
+ <item>
+ <spacer name="horizontalSpacer_5">
+ <property name="orientation">
+ <enum>Qt::Horizontal</enum>
+ </property>
+ <property name="sizeType">
+ <enum>QSizePolicy::Fixed</enum>
+ </property>
+ <property name="sizeHint" stdset="0">
+ <size>
+ <width>13</width>
+ <height>20</height>
+ </size>
+ </property>
+ </spacer>
+ </item>
+ <item>
+ <widget class="MonBoutonValide" name="RBValide">
+ <property name="minimumSize">
+ <size>
+ <width>17</width>
+ <height>31</height>
+ </size>
+ </property>
+ <property name="maximumSize">
+ <size>
+ <width>21</width>
+ <height>31</height>
+ </size>
+ </property>
+ <property name="focusPolicy">
+ <enum>Qt::ClickFocus</enum>
+ </property>
+ <property name="toolTip">
+ <string>Affiche le rapport de validité de la commande</string>
+ </property>
+ <property name="styleSheet">
+ <string notr="true">border : 0px</string>
+ </property>
+ <property name="text">
+ <string>...</string>
+ </property>
+ <property name="icon">
+ <iconset>
+ <normaloff>../../../.designer/Editeur/icons/ast-green-ball.png</normaloff>../../../.designer/Editeur/icons/ast-green-ball.png</iconset>
+ </property>
+ <property name="iconSize">
+ <size>
+ <width>21</width>
+ <height>31</height>
+ </size>
+ </property>
+ </widget>
+ </item>
+ <item>
+ <spacer name="horizontalSpacer_3">
+ <property name="orientation">
+ <enum>Qt::Horizontal</enum>
+ </property>
+ <property name="sizeType">
+ <enum>QSizePolicy::Fixed</enum>
+ </property>
+ <property name="sizeHint" stdset="0">
+ <size>
+ <width>13</width>
+ <height>20</height>
+ </size>
+ </property>
+ </spacer>
+ </item>
+ <item>
+ <widget class="MonLabelClic" name="labelNomCommande">
+ <property name="sizePolicy">
+ <sizepolicy hsizetype="MinimumExpanding" vsizetype="Fixed">
+ <horstretch>0</horstretch>
+ <verstretch>0</verstretch>
+ </sizepolicy>
+ </property>
+ <property name="minimumSize">
+ <size>
+ <width>150</width>
+ <height>31</height>
+ </size>
+ </property>
+ <property name="frameShape">
+ <enum>QFrame::NoFrame</enum>
+ </property>
+ <property name="frameShadow">
+ <enum>QFrame::Raised</enum>
+ </property>
+ <property name="text">
+ <string><html><head/><body><p><span style=" color:#0000ff;">commande </span></p></body></html></string>
+ </property>
+ </widget>
+ </item>
+ <item>
+ <widget class="QLineEdit" name="LENom">
+ <property name="sizePolicy">
+ <sizepolicy hsizetype="Fixed" vsizetype="Preferred">
+ <horstretch>0</horstretch>
+ <verstretch>0</verstretch>
+ </sizepolicy>
+ </property>
+ <property name="minimumSize">
+ <size>
+ <width>0</width>
+ <height>40</height>
+ </size>
+ </property>
+ <property name="maximumSize">
+ <size>
+ <width>16777215</width>
+ <height>200</height>
+ </size>
+ </property>
+ <property name="toolTip">
+ <string>Nom de l'objet. Seuls, les objets valides peuvent être nommés</string>
+ </property>
+ <property name="styleSheet">
+ <string notr="true"> QLineEdit {
border: 2px solid gray;
border-radius: 10px;
padding: 0 8px;
}
/*read-only {
background: lightblue;*/</string>
- </property>
- <property name="readOnly">
- <bool>false</bool>
- </property>
- </widget>
- </item>
- <item>
- <spacer name="horizontalSpacer_7">
- <property name="orientation">
- <enum>Qt::Horizontal</enum>
- </property>
- <property name="sizeHint" stdset="0">
- <size>
- <width>108</width>
- <height>20</height>
- </size>
- </property>
- </spacer>
- </item>
- <item>
- <spacer name="horizontalSpacer_2">
- <property name="orientation">
- <enum>Qt::Horizontal</enum>
- </property>
- <property name="sizeType">
- <enum>QSizePolicy::Ignored</enum>
- </property>
- <property name="sizeHint" stdset="0">
- <size>
- <width>2</width>
- <height>40</height>
- </size>
- </property>
- </spacer>
- </item>
- <item>
- <layout class="QHBoxLayout" name="horizontalLayout_2">
- <property name="spacing">
- <number>4</number>
- </property>
- <property name="sizeConstraint">
- <enum>QLayout::SetFixedSize</enum>
- </property>
- <item>
- <widget class="QToolButton" name="RBRun">
- <property name="minimumSize">
- <size>
- <width>21</width>
- <height>31</height>
- </size>
- </property>
- <property name="maximumSize">
- <size>
- <width>21</width>
- <height>31</height>
- </size>
- </property>
- <property name="focusPolicy">
- <enum>Qt::ClickFocus</enum>
- </property>
- <property name="toolTip">
- <string>Lance un script associé à la commande</string>
- </property>
- <property name="styleSheet">
- <string notr="true">border : 0px</string>
- </property>
- <property name="text">
- <string>...</string>
- </property>
- <property name="icon">
- <iconset>
- <normaloff>../../../.designer/Editeur/icons/roue.png</normaloff>../../../.designer/Editeur/icons/roue.png</iconset>
- </property>
- <property name="iconSize">
- <size>
- <width>21</width>
- <height>31</height>
- </size>
- </property>
- </widget>
- </item>
- <item>
- <widget class="QComboBox" name="CBScripts">
- <property name="sizePolicy">
- <sizepolicy hsizetype="Preferred" vsizetype="Fixed">
- <horstretch>0</horstretch>
- <verstretch>0</verstretch>
- </sizepolicy>
- </property>
- <property name="minimumSize">
- <size>
- <width>0</width>
- <height>38</height>
- </size>
- </property>
- <property name="frame">
- <bool>true</bool>
- </property>
- </widget>
- </item>
- <item>
- <widget class="QToolButton" name="RBInfo">
- <property name="minimumSize">
- <size>
- <width>21</width>
- <height>31</height>
- </size>
- </property>
- <property name="maximumSize">
- <size>
- <width>31</width>
- <height>31</height>
- </size>
- </property>
- <property name="focusPolicy">
- <enum>Qt::ClickFocus</enum>
- </property>
- <property name="toolTip">
- <string>ouvre un navigateur sur l'aide contextuelle</string>
- </property>
- <property name="styleSheet">
- <string notr="true">border : 0px</string>
- </property>
- <property name="text">
- <string>...</string>
- </property>
- <property name="icon">
- <iconset>
- <normaloff>../../../.designer/Editeur/icons/point-interrogation.png</normaloff>../../../.designer/Editeur/icons/point-interrogation.png</iconset>
- </property>
- <property name="iconSize">
- <size>
- <width>21</width>
- <height>31</height>
- </size>
- </property>
- </widget>
- </item>
- <item>
- <widget class="QToolButton" name="RBRegle">
- <property name="minimumSize">
- <size>
- <width>21</width>
- <height>31</height>
- </size>
- </property>
- <property name="maximumSize">
- <size>
- <width>31</width>
- <height>31</height>
- </size>
- </property>
- <property name="focusPolicy">
- <enum>Qt::ClickFocus</enum>
- </property>
- <property name="toolTip">
- <string>affiche les régles de validité</string>
- </property>
- <property name="styleSheet">
- <string notr="true">border : 0px</string>
- </property>
- <property name="text">
- <string>...</string>
- </property>
- <property name="icon">
- <iconset>
- <normaloff>../../../.designer/Editeur/icons/lettreRblanc30.png</normaloff>../../../.designer/Editeur/icons/lettreRblanc30.png</iconset>
- </property>
- <property name="iconSize">
- <size>
- <width>21</width>
- <height>31</height>
- </size>
- </property>
- </widget>
- </item>
- </layout>
- </item>
- <item>
- <spacer name="horizontalSpacer_4">
- <property name="orientation">
- <enum>Qt::Horizontal</enum>
- </property>
- <property name="sizeType">
- <enum>QSizePolicy::Fixed</enum>
- </property>
- <property name="sizeHint" stdset="0">
- <size>
- <width>13</width>
- <height>20</height>
- </size>
- </property>
- </spacer>
- </item>
- <item>
- <widget class="QToolButton" name="RBPoubelle">
- <property name="minimumSize">
- <size>
- <width>21</width>
- <height>31</height>
- </size>
- </property>
- <property name="maximumSize">
- <size>
- <width>21</width>
- <height>31</height>
- </size>
- </property>
- <property name="focusPolicy">
- <enum>Qt::ClickFocus</enum>
- </property>
- <property name="toolTip">
- <string>Détruit la commande</string>
- </property>
- <property name="styleSheet">
- <string notr="true">border : 0px</string>
- </property>
- <property name="text">
- <string>...</string>
- </property>
- <property name="icon">
- <iconset>
- <normaloff>../../../.designer/Editeur/icons/deleteRond.png</normaloff>../../../.designer/Editeur/icons/deleteRond.png</iconset>
- </property>
- <property name="iconSize">
- <size>
- <width>21</width>
- <height>31</height>
- </size>
- </property>
- </widget>
- </item>
- </layout>
- <zorder>RBValide</zorder>
- <zorder>labelNomCommande</zorder>
- <zorder>LENom</zorder>
- <zorder>horizontalSpacer_3</zorder>
- <zorder>horizontalSpacer_4</zorder>
- <zorder>RBPoubelle</zorder>
- <zorder>horizontalSpacer_5</zorder>
- <zorder>horizontalSpacer_7</zorder>
- </widget>
- </item>
- <item row="0" column="1">
- <widget class="QPushButton" name="bCatalogue">
- <property name="sizePolicy">
- <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
- <horstretch>0</horstretch>
- <verstretch>0</verstretch>
- </sizepolicy>
- </property>
- <property name="minimumSize">
- <size>
- <width>160</width>
- <height>40</height>
- </size>
- </property>
- <property name="focusPolicy">
- <enum>Qt::ClickFocus</enum>
- </property>
- <property name="toolTip">
- <string>Affiche les commandes possibles</string>
- </property>
- <property name="styleSheet">
- <string notr="true">background-color:rgb(104,110,149);
-color :white;
-border-radius : 12px
-</string>
- </property>
- <property name="text">
- <string>&Commandes</string>
- </property>
- <property name="shortcut">
- <string>Shift+A, Alt+A, Alt+A, Alt+A</string>
- </property>
- <property name="autoDefault">
- <bool>true</bool>
- </property>
- <property name="default">
- <bool>true</bool>
- </property>
- </widget>
- </item>
- <item row="1" column="0">
- <widget class="QLabel" name="labelDoc">
- <property name="text">
- <string>TextLabel</string>
- </property>
- </widget>
- </item>
- <item row="1" column="1">
- <layout class="QGridLayout" name="gridLayout">
- <property name="verticalSpacing">
- <number>0</number>
- </property>
- <item row="0" column="0">
- <widget class="QPushButton" name="bAvant">
+ </property>
+ <property name="readOnly">
+ <bool>false</bool>
+ </property>
+ </widget>
+ </item>
+ <item>
+ <spacer name="horizontalSpacer_7">
+ <property name="orientation">
+ <enum>Qt::Horizontal</enum>
+ </property>
+ <property name="sizeHint" stdset="0">
+ <size>
+ <width>18</width>
+ <height>17</height>
+ </size>
+ </property>
+ </spacer>
+ </item>
+ <item>
+ <widget class="QToolButton" name="RBRun">
+ <property name="minimumSize">
+ <size>
+ <width>21</width>
+ <height>31</height>
+ </size>
+ </property>
+ <property name="maximumSize">
+ <size>
+ <width>21</width>
+ <height>31</height>
+ </size>
+ </property>
+ <property name="focusPolicy">
+ <enum>Qt::ClickFocus</enum>
+ </property>
+ <property name="toolTip">
+ <string>Lance un script associé à la commande</string>
+ </property>
+ <property name="styleSheet">
+ <string notr="true">border : 0px</string>
+ </property>
+ <property name="text">
+ <string>...</string>
+ </property>
+ <property name="icon">
+ <iconset>
+ <normaloff>../../../.designer/Editeur/icons/roue.png</normaloff>../../../.designer/Editeur/icons/roue.png</iconset>
+ </property>
+ <property name="iconSize">
+ <size>
+ <width>21</width>
+ <height>31</height>
+ </size>
+ </property>
+ </widget>
+ </item>
+ <item>
+ <widget class="QComboBox" name="CBScripts">
+ <property name="sizePolicy">
+ <sizepolicy hsizetype="Preferred" vsizetype="Fixed">
+ <horstretch>0</horstretch>
+ <verstretch>0</verstretch>
+ </sizepolicy>
+ </property>
+ <property name="minimumSize">
+ <size>
+ <width>150</width>
+ <height>38</height>
+ </size>
+ </property>
+ <property name="frame">
+ <bool>true</bool>
+ </property>
+ </widget>
+ </item>
+ <item>
+ <widget class="QToolButton" name="RBRegle">
+ <property name="minimumSize">
+ <size>
+ <width>21</width>
+ <height>31</height>
+ </size>
+ </property>
+ <property name="maximumSize">
+ <size>
+ <width>31</width>
+ <height>31</height>
+ </size>
+ </property>
+ <property name="focusPolicy">
+ <enum>Qt::ClickFocus</enum>
+ </property>
+ <property name="toolTip">
+ <string>affiche les régles de validité</string>
+ </property>
+ <property name="styleSheet">
+ <string notr="true">border : 0px</string>
+ </property>
+ <property name="text">
+ <string>...</string>
+ </property>
+ <property name="icon">
+ <iconset>
+ <normaloff>../../../.designer/Editeur/icons/lettreRblanc30.png</normaloff>../../../.designer/Editeur/icons/lettreRblanc30.png</iconset>
+ </property>
+ <property name="iconSize">
+ <size>
+ <width>21</width>
+ <height>31</height>
+ </size>
+ </property>
+ </widget>
+ </item>
+ <item>
+ <widget class="QToolButton" name="RBInfo">
+ <property name="minimumSize">
+ <size>
+ <width>21</width>
+ <height>31</height>
+ </size>
+ </property>
+ <property name="maximumSize">
+ <size>
+ <width>31</width>
+ <height>31</height>
+ </size>
+ </property>
+ <property name="focusPolicy">
+ <enum>Qt::ClickFocus</enum>
+ </property>
+ <property name="toolTip">
+ <string>ouvre un navigateur sur l'aide contextuelle</string>
+ </property>
+ <property name="styleSheet">
+ <string notr="true">border : 0px</string>
+ </property>
+ <property name="text">
+ <string>...</string>
+ </property>
+ <property name="icon">
+ <iconset>
+ <normaloff>../../../.designer/Editeur/icons/point-interrogation.png</normaloff>../../../.designer/Editeur/icons/point-interrogation.png</iconset>
+ </property>
+ <property name="iconSize">
+ <size>
+ <width>21</width>
+ <height>31</height>
+ </size>
+ </property>
+ </widget>
+ </item>
+ <item>
+ <spacer name="horizontalSpacer_4">
+ <property name="orientation">
+ <enum>Qt::Horizontal</enum>
+ </property>
+ <property name="sizeType">
+ <enum>QSizePolicy::Fixed</enum>
+ </property>
+ <property name="sizeHint" stdset="0">
+ <size>
+ <width>13</width>
+ <height>20</height>
+ </size>
+ </property>
+ </spacer>
+ </item>
+ <item>
+ <widget class="QToolButton" name="RBPoubelle">
+ <property name="minimumSize">
+ <size>
+ <width>21</width>
+ <height>31</height>
+ </size>
+ </property>
+ <property name="maximumSize">
+ <size>
+ <width>21</width>
+ <height>31</height>
+ </size>
+ </property>
+ <property name="focusPolicy">
+ <enum>Qt::ClickFocus</enum>
+ </property>
+ <property name="toolTip">
+ <string>Détruit la commande</string>
+ </property>
+ <property name="styleSheet">
+ <string notr="true">border : 0px</string>
+ </property>
+ <property name="text">
+ <string>...</string>
+ </property>
+ <property name="icon">
+ <iconset>
+ <normaloff>../../../.designer/Editeur/icons/deleteRond.png</normaloff>../../../.designer/Editeur/icons/deleteRond.png</iconset>
+ </property>
+ <property name="iconSize">
+ <size>
+ <width>21</width>
+ <height>31</height>
+ </size>
+ </property>
+ </widget>
+ </item>
+ </layout>
+ </item>
+ <item>
+ <widget class="QLabel" name="labelDoc">
<property name="sizePolicy">
- <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
+ <sizepolicy hsizetype="Preferred" vsizetype="Fixed">
<horstretch>0</horstretch>
<verstretch>0</verstretch>
</sizepolicy>
</property>
- <property name="minimumSize">
- <size>
- <width>60</width>
- <height>24</height>
- </size>
- </property>
- <property name="maximumSize">
- <size>
- <width>60</width>
- <height>24</height>
- </size>
- </property>
- <property name="focusPolicy">
- <enum>Qt::ClickFocus</enum>
- </property>
- <property name="toolTip">
- <string>Affiche le formulaire de la commande précédente</string>
- </property>
- <property name="styleSheet">
- <string notr="true">background-color:rgb(104,110,149);
-color :white;
-border-radius : 12px
-</string>
- </property>
<property name="text">
- <string><<</string>
- </property>
- <property name="shortcut">
- <string>Shift+A, Alt+A, Alt+A, Alt+A</string>
- </property>
- <property name="autoDefault">
- <bool>true</bool>
- </property>
- <property name="default">
- <bool>true</bool>
+ <string>TextLabel</string>
</property>
</widget>
</item>
- <item row="0" column="1">
- <widget class="QPushButton" name="bApres">
+ </layout>
+ </item>
+ <item>
+ <layout class="QVBoxLayout" name="verticalLayout_2">
+ <property name="spacing">
+ <number>1</number>
+ </property>
+ <property name="sizeConstraint">
+ <enum>QLayout::SetFixedSize</enum>
+ </property>
+ <item>
+ <widget class="QPushButton" name="bCatalogue">
<property name="sizePolicy">
<sizepolicy hsizetype="Fixed" vsizetype="Fixed">
<horstretch>0</horstretch>
</property>
<property name="minimumSize">
<size>
- <width>60</width>
- <height>24</height>
- </size>
- </property>
- <property name="maximumSize">
- <size>
- <width>60</width>
- <height>24</height>
+ <width>160</width>
+ <height>30</height>
</size>
</property>
<property name="focusPolicy">
<enum>Qt::ClickFocus</enum>
</property>
<property name="toolTip">
- <string>Affiche le formulaire de la commande suivante</string>
+ <string>Affiche les commandes possibles</string>
</property>
<property name="styleSheet">
<string notr="true">background-color:rgb(104,110,149);
</string>
</property>
<property name="text">
- <string>>></string>
+ <string>&Commandes</string>
</property>
<property name="shortcut">
<string>Shift+A, Alt+A, Alt+A, Alt+A</string>
</property>
</widget>
</item>
- <item row="1" column="0">
+ <item>
+ <layout class="QHBoxLayout" name="horizontalLayout_3">
+ <property name="spacing">
+ <number>1</number>
+ </property>
+ <item>
+ <widget class="QPushButton" name="bAvant">
+ <property name="sizePolicy">
+ <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
+ <horstretch>0</horstretch>
+ <verstretch>0</verstretch>
+ </sizepolicy>
+ </property>
+ <property name="minimumSize">
+ <size>
+ <width>60</width>
+ <height>24</height>
+ </size>
+ </property>
+ <property name="maximumSize">
+ <size>
+ <width>60</width>
+ <height>24</height>
+ </size>
+ </property>
+ <property name="focusPolicy">
+ <enum>Qt::ClickFocus</enum>
+ </property>
+ <property name="toolTip">
+ <string>Affiche le formulaire de la commande précédente</string>
+ </property>
+ <property name="styleSheet">
+ <string notr="true">background-color:rgb(104,110,149);
+color :white;
+border-radius : 12px
+</string>
+ </property>
+ <property name="text">
+ <string><<</string>
+ </property>
+ <property name="shortcut">
+ <string>Shift+A, Alt+A, Alt+A, Alt+A</string>
+ </property>
+ <property name="autoDefault">
+ <bool>true</bool>
+ </property>
+ <property name="default">
+ <bool>true</bool>
+ </property>
+ </widget>
+ </item>
+ <item>
+ <widget class="QPushButton" name="bApres">
+ <property name="sizePolicy">
+ <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
+ <horstretch>0</horstretch>
+ <verstretch>0</verstretch>
+ </sizepolicy>
+ </property>
+ <property name="minimumSize">
+ <size>
+ <width>60</width>
+ <height>24</height>
+ </size>
+ </property>
+ <property name="maximumSize">
+ <size>
+ <width>60</width>
+ <height>24</height>
+ </size>
+ </property>
+ <property name="focusPolicy">
+ <enum>Qt::ClickFocus</enum>
+ </property>
+ <property name="toolTip">
+ <string>Affiche le formulaire de la commande suivante</string>
+ </property>
+ <property name="styleSheet">
+ <string notr="true">background-color:rgb(104,110,149);
+color :white;
+border-radius : 12px
+</string>
+ </property>
+ <property name="text">
+ <string>>></string>
+ </property>
+ <property name="shortcut">
+ <string>Shift+A, Alt+A, Alt+A, Alt+A</string>
+ </property>
+ <property name="autoDefault">
+ <bool>true</bool>
+ </property>
+ <property name="default">
+ <bool>true</bool>
+ </property>
+ </widget>
+ </item>
+ </layout>
+ </item>
+ <item>
<spacer name="verticalSpacer_2">
<property name="orientation">
<enum>Qt::Vertical</enum>
<property name="sizeHint" stdset="0">
<size>
<width>20</width>
- <height>0</height>
+ <height>2</height>
</size>
</property>
</spacer>
<rect>
<x>0</x>
<y>0</y>
- <width>1353</width>
- <height>466</height>
+ <width>1110</width>
+ <height>669</height>
</rect>
</property>
- <layout class="QVBoxLayout" name="verticalLayout">
+ <layout class="QVBoxLayout" name="verticalLayout_4">
+ <property name="spacing">
+ <number>0</number>
+ </property>
+ <property name="margin">
+ <number>0</number>
+ </property>
<item>
<layout class="QVBoxLayout" name="commandesLayout">
<property name="spacing">
- <number>1</number>
+ <number>0</number>
</property>
</layout>
</item>
- <item>
- <spacer name="verticalSpacer">
- <property name="orientation">
- <enum>Qt::Vertical</enum>
- </property>
- <property name="sizeHint" stdset="0">
- <size>
- <width>20</width>
- <height>5</height>
- </size>
- </property>
- </spacer>
- </item>
</layout>
</widget>
</widget>
<rect>
<x>0</x>
<y>0</y>
- <width>764</width>
- <height>86</height>
+ <width>1122</width>
+ <height>163</height>
</rect>
</property>
<property name="sizePolicy">
<x>0</x>
<y>0</y>
<width>300</width>
- <height>57</height>
+ <height>101</height>
</rect>
</property>
<property name="sizePolicy">
- <sizepolicy hsizetype="Expanding" vsizetype="Preferred">
+ <sizepolicy hsizetype="Expanding" vsizetype="Expanding">
<horstretch>0</horstretch>
<verstretch>0</verstretch>
</sizepolicy>
</property>
<layout class="QHBoxLayout" name="horizontalLayout_7">
+ <property name="spacing">
+ <number>0</number>
+ </property>
+ <property name="leftMargin">
+ <number>0</number>
+ </property>
+ <property name="topMargin">
+ <number>0</number>
+ </property>
+ <property name="rightMargin">
+ <number>0</number>
+ </property>
+ <property name="bottomMargin">
+ <number>0</number>
+ </property>
<item>
<widget class="QLabel" name="monCommentaireLabel">
<property name="sizePolicy">
- <sizepolicy hsizetype="Expanding" vsizetype="MinimumExpanding">
+ <sizepolicy hsizetype="Expanding" vsizetype="Expanding">
<horstretch>0</horstretch>
<verstretch>0</verstretch>
</sizepolicy>
</property>
+ <property name="minimumSize">
+ <size>
+ <width>300</width>
+ <height>0</height>
+ </size>
+ </property>
<property name="text">
- <string>TextLabel</string>
+ <string><html><head/><body><p>les types des tuples</p></body></html></string>
</property>
</widget>
</item>
<property name="lineWidth">
<number>1</number>
</property>
- <property name="sizeAdjustPolicy">
- <enum>QAbstractScrollArea::AdjustToContentsOnFirstShow</enum>
- </property>
<property name="widgetResizable">
<bool>true</bool>
</property>
<rect>
<x>0</x>
<y>0</y>
- <width>398</width>
- <height>48</height>
+ <width>705</width>
+ <height>122</height>
</rect>
</property>
<property name="sizePolicy">
<rect>
<x>0</x>
<y>0</y>
- <width>612</width>
- <height>175</height>
+ <width>662</width>
+ <height>163</height>
</rect>
</property>
<property name="sizePolicy">
- <sizepolicy hsizetype="Preferred" vsizetype="MinimumExpanding">
+ <sizepolicy hsizetype="Preferred" vsizetype="Expanding">
<horstretch>0</horstretch>
<verstretch>0</verstretch>
</sizepolicy>
<string>Form</string>
</property>
<layout class="QHBoxLayout" name="horizontalLayout_2">
- <property name="spacing">
- <number>0</number>
- </property>
- <property name="leftMargin">
- <number>0</number>
- </property>
- <property name="topMargin">
- <number>2</number>
- </property>
- <property name="rightMargin">
- <number>0</number>
- </property>
- <property name="bottomMargin">
- <number>2</number>
- </property>
<item>
<layout class="QVBoxLayout" name="verticalLayout_5">
<item>
</widget>
</item>
<item>
- <widget class="QScrollArea" name="scrollArea_2">
+ <widget class="QLabel" name="monCommentaireLabel">
<property name="sizePolicy">
<sizepolicy hsizetype="Fixed" vsizetype="Expanding">
<horstretch>0</horstretch>
<verstretch>0</verstretch>
</sizepolicy>
</property>
- <property name="frameShape">
- <enum>QFrame::NoFrame</enum>
+ <property name="minimumSize">
+ <size>
+ <width>300</width>
+ <height>0</height>
+ </size>
</property>
- <property name="frameShadow">
- <enum>QFrame::Plain</enum>
+ <property name="maximumSize">
+ <size>
+ <width>300</width>
+ <height>16777215</height>
+ </size>
</property>
- <property name="widgetResizable">
- <bool>true</bool>
+ <property name="text">
+ <string><html><head/><body><p>TextLabel dqDFDQ</p><p><br/></p></body></html></string>
</property>
- <widget class="QWidget" name="scrollAreaWidgetContents">
- <property name="geometry">
- <rect>
- <x>0</x>
- <y>0</y>
- <width>82</width>
- <height>111</height>
- </rect>
- </property>
- <property name="sizePolicy">
- <sizepolicy hsizetype="Fixed" vsizetype="Preferred">
- <horstretch>0</horstretch>
- <verstretch>0</verstretch>
- </sizepolicy>
- </property>
- <layout class="QVBoxLayout" name="verticalLayout_7">
- <item>
- <widget class="QLabel" name="monCommentaireLabel">
- <property name="sizePolicy">
- <sizepolicy hsizetype="MinimumExpanding" vsizetype="MinimumExpanding">
- <horstretch>0</horstretch>
- <verstretch>0</verstretch>
- </sizepolicy>
- </property>
- <property name="text">
- <string>TextLabel</string>
- </property>
- </widget>
- </item>
- </layout>
- </widget>
</widget>
</item>
</layout>
<rect>
<x>0</x>
<y>0</y>
- <width>197</width>
- <height>110</height>
+ <width>211</width>
+ <height>84</height>
</rect>
</property>
<property name="sizePolicy">
<x>0</x>
<y>0</y>
<width>743</width>
- <height>60</height>
+ <height>31</height>
</rect>
</property>
<property name="sizePolicy">
<number>0</number>
</property>
<property name="leftMargin">
- <number>1</number>
+ <number>0</number>
</property>
<property name="topMargin">
<number>0</number>
<number>0</number>
</property>
<property name="bottomMargin">
- <number>1</number>
+ <number>0</number>
</property>
<item>
<layout class="QVBoxLayout" name="verticalLayout_2">
</property>
<property name="maximumSize">
<size>
- <width>178</width>
+ <width>300</width>
<height>16777215</height>
</size>
</property>
<enum>QFrame::NoFrame</enum>
</property>
<property name="text">
- <string><html><head/><body><p>aaa</p><p>dqsklmdqm</p></body></html></string>
+ <string><html><head/><body><p><br/></p></body></html></string>
</property>
<property name="scaledContents">
<bool>false</bool>
<property name="sizeHint" stdset="0">
<size>
<width>20</width>
- <height>5</height>
+ <height>1</height>
</size>
</property>
</spacer>
<property name="minimumSize">
<size>
<width>0</width>
- <height>61</height>
+ <height>60</height>
</size>
</property>
<property name="maximumSize">
<size>
<width>16777215</width>
- <height>61</height>
+ <height>60</height>
</size>
</property>
<property name="styleSheet">
<addaction name="separator"/>
<addaction name="actionParametres"/>
</widget>
+ <widget class="QToolBar" name="toolBarCommande">
+ <property name="windowTitle">
+ <string>toolBar_2</string>
+ </property>
+ <attribute name="toolBarArea">
+ <enum>TopToolBarArea</enum>
+ </attribute>
+ <attribute name="toolBarBreak">
+ <bool>false</bool>
+ </attribute>
+ </widget>
<action name="action_Nouveau">
<property name="icon">
<iconset theme="document-new">
</property>
</action>
<action name="actionLecteur_Pdf">
+ <property name="icon">
+ <iconset theme="edit-delete">
+ <normaloff>.</normaloff>.</iconset>
+ </property>
<property name="text">
<string>Lecteur documentation</string>
</property>
def __init__(self):
self.texte = ''
- def set_text(self,texte):
+ def setText(self,texte):
self.texte = texte
- def append_text(self,texte):
+ def appendText(self,texte):
"""
"""
self.texte = self.texte +texte
t=repr(self.texte)
return "COMMENTAIRE(u"+t+")\n"
- def append_text(self,texte):
+ def appendText(self,texte):
"""
Ajoute texte a self.texte en enlevant le # initial
"""
class AFFECTATION(ENTITE_JDC):
- def append_text(self,texte):
+ def appendText(self,texte):
"""
Ajoute texte a self.texte en enlevant tout retour chariot et tout point virgule
"""
class COMMANDE_COMMENTARISEE(ENTITE_JDC):
- def append_text(self,texte):
+ def appendText(self,texte):
"""
Ajoute texte a self.texte en enlevant les doubles commentaires
"""
self.getoptions()
return self.line
- def get_texte(self,appli=None):
+ def getTexte(self,appli=None):
"""
Retourne le texte issu de l'analyse
"""
for tk in tokenize.generate_tokens(self.readline):
- self.process_token(tk)
+ self.processToken(tk)
return self.out
- def process_token(self, tk):
+ def processToken(self, tk):
"""
"""
ttype, tstring, spos, epos, line = tk
return
if ttype != tokenize.DEDENT and ttype != tokenize.INDENT and self.please_indent:
- self.do_indent()
+ self.doIndent()
fn(tstring)
self.lastrow, self.lastcol = epos
self.out=self.out+tstring
- def output_com(self,tstring):
+ def outputCom(self,tstring):
self.out=self.out+tstring
- def update_indent(self):
- #print "update_indent",len(self.indent_list[-1]),len(self.buffer_indent)
+ def updateIndent(self):
+ #print "updateIndent",len(self.indent_list[-1]),len(self.buffer_indent)
if len(self.indent_list[-1]) > len(self.buffer_indent):
self.out=self.out+(len(self.indent_list[-1]) - len(self.buffer_indent))*" "
self.buffer_indent=self.indent_list[-1]
- def do_indent(self):
- #print "indentation dans do_indent",len(self.indent_list)
+ def doIndent(self):
+ #print "indentation dans doIndent",len(self.indent_list)
self.out=self.out+self.indent_list[-1]
self.buffer_indent=self.indent_list[-1]
# print len(self.indent_list),self.please_indent
for ob in self.buffer:
self.out= self.out+ str(ob)
- self.do_indent()
+ self.doIndent()
self.buffer=[]
self.objet_courant=None
self.affectation=0
else:
# affectation en cours, on ajoute
- if self.thiscol > self.lastcol :self.affectation_courante.append_text((self.thiscol - self.lastcol)*" ")
- self.affectation_courante.append_text(tstring)
+ if self.thiscol > self.lastcol :self.affectation_courante.appendText((self.thiscol - self.lastcol)*" ")
+ self.affectation_courante.appendText(tstring)
return
if self.objet_courant:
if not self.buffer:self.buffer_indent=self.indent_list[-1]
self.objet_courant=COMMANDE_COMMENTARISEE()
self.buffer.append(self.objet_courant)
- self.objet_courant.append_text(tstring)
+ self.objet_courant.appendText(tstring)
self.please_indent = None
elif isinstance(self.objet_courant,COMMENTAIRE):
self.objet_courant=COMMANDE_COMMENTARISEE()
self.buffer.append(self.objet_courant)
- self.objet_courant.append_text(tstring)
+ self.objet_courant.appendText(tstring)
self.please_indent = None
else:
- self.objet_courant.append_text(tstring)
+ self.objet_courant.appendText(tstring)
self.please_indent = None
else:
# commentaire inline
if not self.buffer:self.buffer_indent=self.indent_list[-1]
self.objet_courant=COMMENTAIRE()
self.buffer.append(self.objet_courant)
- self.objet_courant.append_text(tstring)
+ self.objet_courant.appendText(tstring)
self.please_indent = None
elif isinstance(self.objet_courant,COMMANDE_COMMENTARISEE):
self.objet_courant=COMMENTAIRE()
self.buffer.append(self.objet_courant)
- self.objet_courant.append_text(tstring)
+ self.objet_courant.appendText(tstring)
self.please_indent = None
else:
- self.objet_courant.append_text(tstring)
+ self.objet_courant.appendText(tstring)
self.please_indent = None
else:
# commentaire inline
def NAME(self, tstring):
if self.buffer:
- self.update_indent()
+ self.updateIndent()
self.flush_buffer()
if self.affectation ==1:
# on ne veut pas des expressions qui commencent par NAME=NAME(NAME=
# on en prend le chemin : on met affectation a 3 pour le signaler
# on attend d'en savoir plus
- if self.thiscol > self.lastcol :self.affectation_courante.append_text((self.thiscol - self.lastcol)*" ")
- self.affectation_courante.append_text(tstring)
+ if self.thiscol > self.lastcol :self.affectation_courante.appendText((self.thiscol - self.lastcol)*" ")
+ self.affectation_courante.appendText(tstring)
self.affectation=3
return
elif self.affectation ==4:
# on a une expression qui commence par NAME=NAME(NAME
# il s'agit tres probablement d'une commande
# on annule l'affectation en cours
- if self.thiscol > self.lastcol :self.affectation_courante.append_text((self.thiscol - self.lastcol)*" ")
- self.affectation_courante.append_text(tstring)
+ if self.thiscol > self.lastcol :self.affectation_courante.appendText((self.thiscol - self.lastcol)*" ")
+ self.affectation_courante.appendText(tstring)
self.affectation=5
return
elif self.affectation == 2:
# affectation en cours, on ajoute
- if self.thiscol > self.lastcol :self.affectation_courante.append_text((self.thiscol - self.lastcol)*" ")
- self.affectation_courante.append_text(tstring)
+ if self.thiscol > self.lastcol :self.affectation_courante.appendText((self.thiscol - self.lastcol)*" ")
+ self.affectation_courante.appendText(tstring)
self.affectation=2
return
self.affectation=0
self.flush_buffer()
if self.affectation>=1:
# affectation en cours, on ajoute
- if self.thiscol > self.lastcol :self.affectation_courante.append_text((self.thiscol - self.lastcol)*" ")
- self.affectation_courante.append_text(tstring)
+ if self.thiscol > self.lastcol :self.affectation_courante.appendText((self.thiscol - self.lastcol)*" ")
+ self.affectation_courante.appendText(tstring)
self.affectation=2
return
self.output(tstring)
elif tstring == '(' and self.affectation == 3:
# on a deja trouve NAME=NAME
# on passe affectation a 4
- if self.thiscol > self.lastcol :self.affectation_courante.append_text((self.thiscol - self.lastcol)*" ")
- self.affectation_courante.append_text(tstring)
+ if self.thiscol > self.lastcol :self.affectation_courante.appendText((self.thiscol - self.lastcol)*" ")
+ self.affectation_courante.appendText(tstring)
self.affectation=4
return
elif tstring == ';' and self.affectation>=1:
self.affectation=0
elif self.affectation>=1:
# on complete l'affectation
- if self.thiscol > self.lastcol :self.affectation_courante.append_text((self.thiscol - self.lastcol)*" ")
- self.affectation_courante.append_text(tstring)
+ if self.thiscol > self.lastcol :self.affectation_courante.appendText((self.thiscol - self.lastcol)*" ")
+ self.affectation_courante.appendText(tstring)
self.affectation=2
return
#print "indentation dans INDENT",len(self.indent_list),len(tstring)
self.affectation=0
if self.buffer:
- self.update_indent()
+ self.updateIndent()
self.flush_buffer()
def DEDENT(self, tstring):
self.out= self.out+ str(self.buffer[0])
if len(self.buffer) > 1:
for ob in self.buffer[1:]:
- self.do_indent()
+ self.doIndent()
self.out= self.out+ str(ob)
self.buffer=[]
self.objet_courant=None
self.flush_buffer()
if self.affectation>=1:
# affectation en cours, on ajoute
- if self.thiscol > self.lastcol :self.affectation_courante.append_text((self.thiscol - self.lastcol)*" ")
- self.affectation_courante.append_text(tstring)
+ if self.thiscol > self.lastcol :self.affectation_courante.appendText((self.thiscol - self.lastcol)*" ")
+ self.affectation_courante.appendText(tstring)
self.affectation=2
return
self.output(tstring)
f.close()
else:
t=text
- txt = PARSEUR_PYTHON(t).get_texte()
+ txt = PARSEUR_PYTHON(t).getTexte()
print (txt)
compile(txt,"<string>",'exec')
--- /dev/null
+# Copyright (C) 2007-2017 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+from __future__ import absolute_import
+
+
+#from Extensions.i18n import tr
+#from Extensions import localisation
+
+
+from .convert_python import PythonParser
+from Noyau import N_CR
+
+try:
+ basestring
+except NameError:
+ basestring = str
+
+
+
+def entryPoint():
+ """
+ Return a dictionary containing the description needed to load the plugin
+ """
+ return {
+ 'name' : 'dico',
+ 'factory' : DicoParser
+ }
+
+class DicoParser(PythonParser):
+ """
+ This converter initializes model variable from a python dictionnary
+ """
+
+ def __init__(self,cr=None):
+ # Si l'objet compte-rendu n'est pas fourni, on utilise le
+ # compte-rendu standard
+ self.text=''
+ self.textePy=''
+ if cr :
+ self.cr=cr
+ else:
+ self.cr=N_CR.CR(debut='CR convertisseur format dico',
+ fin='fin CR format dico')
+
+ def readfile(self,filename):
+ self.filename=filename
+ try:
+ self.text=open(filename).read()
+ except:
+ self.cr.exception(tr("Impossible d'ouvrir le fichier %s" ,str(filename)))
+ self.cr.fatal(tr("Impossible d'ouvrir le fichier %s" ,str(filename)))
+ return
+
+ def convert(self,outformat,appli=None):
+ monTexteDico={}
+ exec (self.text,globals(),monTexteDico)
+ if len(monTexteDico.keys()) != 1 :
+ self.cr.exception(tr("Impossible de traiter le fichier %s" ,str(filename)))
+ self.cr.fatal(tr("Impossible de traiter le fichier %s" ,str(filename)))
+ return
+ self.textePy=""
+ monDico=monTexteDico[monTexteDico.keys()[0]]
+ for commande in monDico :
+ valeurs=monDico[commande]
+ if valeurs.has_key('NomDeLaSdCommande') :
+ # cas d un oper
+ self.textePy+=valeurs['NomDeLaSdCommande']+' = '+commande+'('
+ del valeurs['NomDeLaSdCommande']
+ else :
+ self.textePy+=commande+'('
+ for mot in valeurs :
+ if isinstance(valeurs[mot],dict) : self.traiteMCFact(mot,valeurs[mot])
+ else : self.textePy += mot+' = ' +str(valeurs[mot])+','
+ self.textePy+=');\n' # fin de la commande
+ print (self.textePy)
+ return self.textePy
+
+ def traiteMCFact(self,mot,valeurs):
+ self.textePy += mot + '=_F('
+ for mot in valeurs :
+ if isinstance(valeurs[mot],dict) : self.traiteMCFact(mot,valeurs[mot])
+ else : self.textePy +=mot+' = ' +str(valeurs[mot])+','
+ self.textePy +='),'
+
#import cProfile, pstats, StringIO
#pr = cProfile.Profile()
#pr.enable()
- l= PARSEUR_PYTHON(self.text).get_texte(appli)
+ l= PARSEUR_PYTHON(self.text).getTexte(appli)
#pr.disable()
#s = StringIO.StringIO()
)
""",re.VERBOSE|re.MULTILINE)
-def construit_genea(texte,liste_mc):
+def construitGenea(texte,liste_mc):
"""
Retourne un dictionnaire dont les cles sont des reels et les valeurs sont leurs representations textuelles.
>>> s = '''a=+21.3e-5*85,b=-.1234,c=81.6 , d= -8 , e=_F(x=342.67,y=-1), f=+1.1, g=(1.3,-5,1.54E-3),
... #POMPE_PRIMA._BOUCLE_N._2_ELEMENT_NUMERO:0239
... h=_F(x=34.6,y=-1)'''
- >>> construit_genea(s,['a','x'])
+ >>> construitGenea(s,['a','x'])
{0.000213: '21.3e-5'}
"""
d={}
self.texte = ''
pere.l_objets.append(self)
- def set_text(self,texte):
+ def setText(self,texte):
self.texte = texte
- def append_text(self,texte):
+ def appendText(self,texte):
"""
Ajoute texte a self.texte en mettant un retour chariot a la fin de texte
"""
#s='COMMENTAIRE(u"""'+self.texte+'""")\n\n'
#return s
- def append_text(self,texte):
+ def appendText(self,texte):
"""
Ajoute texte a self.texte en enlevant le # initial
"""
"""
return self.texte+'\n'
- def get_nb_par(self):
+ def getNbPar(self):
"""
Retourne la difference entre le nombre de parentheses ouvrantes
et le nombre de parentheses fermantes presentes dans self.texte
class AFFECTATION(ENTITE_JDC):
- def append_text(self,texte):
+ def appendText(self,texte):
"""
Ajoute texte a self.texte en enlevant tout retour chariot et tout point virgule
PN et tout commentaire
class COMMANDE_COMMENTARISEE(ENTITE_JDC):
- def append_text(self,texte):
+ def appendText(self,texte):
"""
Ajoute texte a self.texte en enlevant les doubles commentaires
"""
class AFFECTATION_EVAL(ENTITE_JDC):
- def append_text(self,texte):
+ def appendText(self,texte):
"""
Ajoute texte a self.texte en enlevant tout retour chariot
"""
self.l_objets=None
self.appli=None
- def is_affectation(self,texte):
+ def isAffectation(self,texte):
"""
Methode booleenne qui retourne 1 si le texte est celui d'une affectation dans un jeu de commandes
Aster, 0 sinon
if m.end() != len(s):return 0
return 1
- def is_eval(self,texte):
+ def isEval(self,texte):
"""
Methode booleenne qui retourne 1 si le texte est celui d'une affectation de type EVAL
dans un jeu de commandes Aster, 0 sinon
else:
return 0
- def is_commande(self,texte):
+ def isCommande(self,texte):
"""
Methode booleenne qui retourne 1 si le texte est celui d'une commande dans un jeu de commandes
Aster, 0 sinon
else:
return 0
- def is_modification_catalogue(self,texte) :
+ def isModificationCatalogue(self,texte) :
if self.pattern_commande.match(texte):
return 1
# on a un objet commentarise a l'interieur d'une commande
# --> non traite pour l'instant : on l'ajoute simplement a la commande courante comme
# un commentaire ordinaire
- commande_courante.append_text(ligne)
+ commande_courante.appendText(ligne)
elif commande_commentarisee_courante :
# commande_commentarisee en cours : on ajoute la ligne
- commande_commentarisee_courante.append_text(ligne)
+ commande_commentarisee_courante.appendText(ligne)
# on a 2 commandes commentarisees de suite
if pattern_finComments.match(ligne) :
commande_commentarisee_courante = None
else:
# debut de commande commentarisee : on cree un objet commande_commentarisee_courante
commande_commentarisee_courante = COMMANDE_COMMENTARISEE(self)
- commande_commentarisee_courante.append_text(ligne)
+ commande_commentarisee_courante.appendText(ligne)
#on passe a la ligne suivante
continue
if commande_courante :
# il s'agit d'un commentaire a l'interieur d'une commande --> on ne fait rien de special
#on l'ajoute au texte de la commande
- commande_courante.append_text(ligne)
+ commande_courante.appendText(ligne)
elif commentaire_courant :
# il s'agit de la nieme ligne d'un commentaire entre deux commandes
# --> on ajoute cette ligne au commentaire courant
- commentaire_courant.append_text(ligne)
+ commentaire_courant.appendText(ligne)
else :
# il s'agit d'un nouveau commentaire entre deux commandes
# --> on le cree et il devient le commentaire courant
commentaire_courant = COMMENTAIRE(self)
- commentaire_courant.append_text(ligne)
+ commentaire_courant.appendText(ligne)
#on passe a la ligne suivante
continue
if commande_courante :
#on a une commande en cours. On l'enrichit ou on la termine
- commande_courante.append_text(ligne)
+ commande_courante.appendText(ligne)
if not linecontinueRE.search(line) \
and (hangingBraces == emptyHangingBraces) \
and not hangingComments:
if affectation_courante != None :
#poursuite d'une affectation
- affectation_courante.append_text(ligne)
+ affectation_courante.appendText(ligne)
if not linecontinueRE.search(line) \
and (hangingBraces == emptyHangingBraces) \
and not hangingComments:
# il peut s'agir d'une commande ou d'une affectation ...
# ou d'un EVAL !!!
- if self.is_eval(ligne):
+ if self.isEval(ligne):
# --> affectation de type EVAL
if affectation_courante : affectation_courante = None
affectation = AFFECTATION_EVAL(self)
- affectation.append_text(ligne)
+ affectation.appendText(ligne)
#on passe a la ligne suivante
continue
- if self.is_affectation(ligne):
+ if self.isAffectation(ligne):
#print( '--> affectation')
text=ligne
#traitement des commentaires en fin de ligne
if compos > 2:
#commentaire en fin de ligne
#on cree un nouveau commentaire avant le parametre
- COMMENTAIRE(self).append_text(ligne[compos:])
+ COMMENTAIRE(self).appendText(ligne[compos:])
text=ligne[:compos]
#si plusieurs instructions separees par des ; sur la meme ligne
inspos=line.find(u";")
sur la meme ligne : %s", ligne))
affectation_courante = AFFECTATION(self)
- affectation_courante.append_text(text)
+ affectation_courante.appendText(text)
if not linecontinueRE.search(line) \
and (hangingBraces == emptyHangingBraces) \
and not hangingComments:
#on passe a la ligne suivante
continue
- if self.is_commande(ligne):
+ if self.isCommande(ligne):
# --> nouvelle commande
affectation_courante = None
commande_courante = COMMANDE(self)
- commande_courante.append_text(ligne)
+ commande_courante.appendText(ligne)
#si la commande est complete, on la termine
if not linecontinueRE.search(line) \
and (hangingBraces == emptyHangingBraces) \
i=i+1
return chaine
- def construit_genea(self,texte):
+ def construitGenea(self,texte):
indiceC=0
mot=""
dict_reel_concept={}
#nomConcept=epure1.split(u"=")[0]
#index=epure1.find(u"=")
#epure2=epure1[index+1:len(epure1)].replace(u"_F(u","(u")
- #dict_reel_concept=self.construit_genea(epure2)
+ #dict_reel_concept=self.construitGenea(epure2)
if self.appli:
- dict_reel_concept=construit_genea(epure2,self.appli.liste_simp_reel)
+ dict_reel_concept=construitGenea(epure2,self.appli.liste_simp_reel)
else:
dict_reel_concept={}
if nomConcept == "sansnom" :
if len(dict_reel_concept) != 0:
self.appli.dict_reels[nomConcept]=dict_reel_concept
- def get_texte(self,appli=None):
+ def getTexte(self,appli=None):
"""
Retourne le texte issu de l'analyse
"""
# Cette instruction genere le contenu du fichier de parametres pour le code Carmel3D
# si le jdc est valide (sinon cela n a pas de sens)
- if obj.isvalid() :
+ if obj.isValid() :
try :
# constitution du bloc VERSION du fichier PHYS (existe toujours)
self.generBLOC_VERSION(obj)
self.dicoCourant=self.dicoMCFACTCourant
s=PythonGenerator.generMCFACT(self,obj)
# sauvegarde, dans self.dicoEtapeCourant, de la valeur du FACT courant, pour utilisation ultérieure dans generETAPE et generPROC_ETAPE
- # Traitement des FACT CUTLINE et CUTPLANE multiples (max='**' dans le catalogue)
+ # traitement des FACT CUTLINE et CUTPLANE multiples (max='**' dans le catalogue)
# Ce traitement spécial est nécessaire pour le moment car le générateur bogue sinon au niveau des matériaux (non-linéaires ?)
if obj.nom in ('FIELDDUMP','CUTLINE', 'CUTPLANE', 'FIELDMAP', 'VISU3D' ):
# Remplissage se self.dicoEtapeCourant pour le nom du FACT courant
# constitution du bloc VERSION du fichier PHYS
# creation d une entite VERSION ; elle sera du type PROC car decrit ainsi
# dans le du catalogue
- version=obj.addentite('VERSION',pos=None)
+ version=obj.addEntite('VERSION',pos=None)
self.generPROC_ETAPE(obj.etapes[0])
self.texteCarmel3D+="["+obj.etapes[0].nom+"\n"
for cle in obj.etapes[0].valeur :
self.texteCarmel3D+=" "+cle+" "+str(obj.etapes[0].valeur[cle])+"\n"
self.texteCarmel3D+="]\n"
# destruction de l entite creee
- obj.suppentite(version)
+ obj.suppEntite(version)
#print 'ERREUR : test erreur boite graphique BLOC_VERSION'
#raise ValueError, 'test erreur boite graphique BLOC_VERSION'
# Cette instruction genere le contenu du fichier de parametres pour le code Carmel3D
# si le jdc est valide (sinon cela n a pas de sens)
- if obj.isvalid() :
+ if obj.isValid() :
try :
# constitution du bloc VERSION du fichier PHYS (existe toujours)
self.generBLOC_VERSION(obj)
# constitution du bloc VERSION du fichier PHYS
# creation d une entite VERSION ; elle sera du type PROC car decrit ainsi
# dans le du catalogue
- version=obj.addentite('VERSION',pos=None)
+ version=obj.addEntite('VERSION',pos=None)
self.generPROC_ETAPE(obj.etapes[0])
self.texteCarmel3D+="["+obj.etapes[0].nom+"\n"
for cle in obj.etapes[0].valeur :
self.texteCarmel3D+=" "+cle+" "+str(obj.etapes[0].valeur[cle])+"\n"
self.texteCarmel3D+="]\n"
# destruction de l entite creee
- obj.suppentite(version)
+ obj.suppEntite(version)
#print 'ERREUR : test erreur boite graphique BLOC_VERSION'
#raise ValueError, 'test erreur boite graphique BLOC_VERSION'
#----------------------------------------------------------------------------------------
def gener(self,obj,format='brut',config=None,appli=None,statut="Entier"):
+ print ('je suis dans le gener pour ', obj)
self.statut=statut
self.langue=appli.langue
self.DicoEnumCasEnInverse={}
def generMCSIMP(self,obj) :
"""recuperation de l objet MCSIMP"""
+ print ('je genere MCSIMP pour', obj.nom)
s=PythonGenerator.generMCSIMP(self,obj)
#if nom in listeSupprime or s == "" : return s
if s == "None," : s=None
if s == "" or s==None : return s
+ print ('je genere MCSIMP 22 pour', obj.nom)
sTelemac=s[0:-1]
if not( type(obj.valeur) in (tuple,list) ):
#if obj.nom in ('PRESCRIBED_FLOWRATES','PRESCRIBED_VELOCITIES','PRESCRIBED_ELEVATIONS') :
# return s
+ # cas des Tuples
+ if obj.waitTuple() and s3 != '' and s3 != 'None':
+ s3=s
+ if s3[-1] == ',': s3=s3[:-1]
+
+
if obj.nom not in self.dicoCataToCas :
if obj.nom == 'Consigne' : return ""
return s
+ print ('apres')
nom=self.dicoCataToCas[obj.nom]
if nom in ["VARIABLES FOR GRAPHIC PRINTOUTS", "VARIABLES POUR LES SORTIES GRAPHIQUES", "VARIABLES TO BE PRINTED","VARIABLES A IMPRIMER"] :
if s3 == "" or s3 == " " : s3 = " "
ligne=nom+ " : " + s3 + "\n"
if len(ligne) > 72 : ligne=self.redecoupeLigne(nom,s3)
+ print ('fin pour ', obj.nom, ligne)
self.texteDico+=ligne
def generMCFACT(self,obj):
# def LIQUID_BOUNDARIES(self,obj):
# print ('jkljklj')
-# if 'BOUNDARY_TYPE' in obj.liste_mc_presents() :
+# if 'BOUNDARY_TYPE' in obj.listeMcPresents() :
# objForme=obj.get_child('BOUNDARY_TYPE')
# valForme=objForme.valeur
# if valForme == None : return
# if valForme == 'Prescribed Unknown':
# nomBloc='b_'+valForme.split(" ")[1]
-# if nomBloc in obj.liste_mc_presents() :
+# if nomBloc in obj.listeMcPresents() :
# objBloc=obj.get_child(nomBloc)
-# valeurPE = objValeur=objBloc.get_child(objBloc.liste_mc_presents()[0]).valeur
-# valeurFE = objValeur=objBloc.get_child(objBloc.liste_mc_presents()[1]).valeur
-# valeurVE = objValeur=objBloc.get_child(objBloc.liste_mc_presents()[2]).valeur
+# valeurPE = objValeur=objBloc.get_child(objBloc.listeMcPresents()[0]).valeur
+# valeurFE = objValeur=objBloc.get_child(objBloc.listeMcPresents()[1]).valeur
+# valeurVE = objValeur=objBloc.get_child(objBloc.listeMcPresents()[2]).valeur
# if valeurPE== None : valeurPE="0."
# if valeurFE== None : valeurPE="0."
# if valeurVE== None : valeurPE="0."
# self.textVE += str(valeurVE) +"; "
# else:
# nomBloc='b_'+valForme.split(" ")[1]
-# if nomBloc in obj.liste_mc_presents() :
+# if nomBloc in obj.listeMcPresents() :
# objBloc=obj.get_child(nomBloc)
-# objValeur=objBloc.get_child(objBloc.liste_mc_presents()[0])
+# objValeur=objBloc.get_child(objBloc.listeMcPresents()[0])
# valeur=objValeur.valeur
# if valeur== None : valeur="0."
# if valForme == 'Prescribed Elevations' :
def NAME_OF_TRACER(self,obj):
print((dir(obj) ))
- print((obj.get_genealogie_precise()))
+ print((obj.getGenealogie_precise()))
def Validation(self,obj):
self.texteDico += "VALIDATION : True \n"
self.texteDico += "UPWIND COEFFICIENTS = "+ str(listeUpwind) + "\n"
def chercheChildren(self,obj):
- for c in obj.liste_mc_presents():
+ for c in obj.listeMcPresents():
objc=obj.get_child(c)
- if hasattr(objc,'liste_mc_presents') and objc.liste_mc_presents() != [] : self.chercheChildren(objc)
+ if hasattr(objc,'listeMcPresents') and objc.listeMcPresents() != [] : self.chercheChildren(objc)
else : self.listeMCAdvection.append(objc)
lval=valeur.split(";")
ligne=" "
for v in lval :
- if len(ligne) < 70 : ligne += str(v)+'; '
+ if len(ligne+ str(v)+'; ') < 72 : ligne += str(v)+'; '
else :
text+= ligne+"\n"
ligne=" "+str(v)+'; '
def writeDefault(self,fn) :
fileDico = fn[:fn.rfind(".")] + '.py'
- f = open( str(fileDico), 'wb')
- f.write( self.texteDico )
- print((self.texteDico))
+ f = open( str(fileDico), 'w')
+ f.write('Dico = '+str(self.Dico))
f.close()
#----------------------------------------------------------------------------------------
"""recuperation de l objet MCSIMP"""
s=PythonGenerator.generMCSIMP(self,obj)
courant=self.Dico
- for p in obj.get_genealogie_precise()[0:-1]:
+ for p in obj.getGenealogie_precise()[0:-1]:
if not (p in courant.keys()) : courant[p]={}
courant=courant[p]
courant[obj.nom]=obj.val
self.texteDico+=obj.nom+ "=" + s[0:-1]+ "\n"
return s
-
# Cette instruction genere le contenu du fichier de commandes (persistance)
self.text=PythonGenerator.gener(self,obj,format)
#print (self.text)
+ print (self.Dico)
return self.text
s=PythonGenerator.generMCSIMP(self,obj)
if obj.isInformation() : return s
- if not obj.isvalid() : return s
+ if not obj.isValid() : return s
- liste=obj.get_genealogie_precise()
+ liste=obj.getGenealogie_precise()
if obj.etape.nom=='MODIFICATION_CATALOGUE' : return s
nom = obj.etape.nom
def gener(self,obj,format='brut',config=None,appli=None):
self.initDico()
self.text=PythonGenerator.gener(self,obj,format)
- if obj.isvalid() :self.genereExeMap()
+ if obj.isValid() :self.genereExeMap()
return self.text
Remplit le dictionnaire des MCSIMP
"""
- if obj.get_genealogie()[0][-6:-1]=="_PARA":
+ if obj.getGenealogie()[0][-6:-1]=="_PARA":
self.dictParam[obj.nom]=obj.valeur
else :
self.dictValeur[obj.nom]=obj.valeur
def generRUN(self,obj,schema):
- if not(obj.isvalid()) :
+ if not(obj.isValid()) :
print ("TODO TODO TODO")
self.texteEXE=""
self.schema=schema
if obj == None :
print ('appel a gener avec None')
return
- self.appli=obj.get_jdc_root().appli
+ self.appli=obj.getJdcRoot().appli
#self.appli=obj.appli
liste= self.generator(obj)
#format='standard'
Methode particuliere pour les objets de type FORMULE
"""
l=[]
- nom = obj.get_nom()
+ nom = obj.getNom()
if nom == '' : nom = 'sansnom'
l.append(nom + ' = FORMULE(')
for v in obj.mc_liste:
if waitTuple :
#s = str(obj.valeur) +','
#obj.valeurFormatee=obj.valeur
- s = obj.GetText() +','
- obj.valeurFormatee=obj.GetText()
+ s = obj.getText() +','
+ obj.valeurFormatee=obj.getText()
else :
obj.valeurFormatee=[]
for val in obj.valeur :
s =s +self.format_item(val,obj.etape,obj,1) + ','
- if obj.wait_TXM() :
+ if obj.waitTxm() :
obj.valeurFormatee.append(val)
else :
obj.valeurFormatee.append(self.format_item(val,obj.etape,obj))
def calcule_ouinon(self,obj):
ouinon=1
- for l in obj.get_genealogie() :
+ for l in obj.getGenealogie() :
if not l in self.liste_motetat :
ouinon=0
break
def generETAPE(self,obj):
"""
"""
- if obj.isvalid() == 0 :
+ if obj.isValid() == 0 :
#showerror("Element non valide","Salome ne sait pas traiter les elements non valides")
return
for v in obj.mc_liste:
def generMACRO_ETAPE(self,obj):
"""
"""
- if obj.isvalid() == 0 :
+ if obj.isValid() == 0 :
#showerror("Element non valide","Salome ne sait pas traiter les elements non valides")
return
for v in obj.mc_liste:
suite = self.__class__.__dict__[obj.nom](self,obj)
else :
clef=self.dict_traduit[obj.nom]
- # Traitement des parametres
+ # traitement des parametres
try :
self.dict_attributs[clef]=obj.val.eval()
except :
print "ListeVariablesOut= %s", ListeVariablesOut
#print "DictLois=", DictLois
self.texteSTD = defaultSTD
- self.OpenTURNS_path = appli.CONFIGURATION.OpenTURNS_path
+ self.OpenTURNS_path = appli.maConfiguration.OpenTURNS_path
# Ce dictionnaire fait la correspondance entre le mot lu dans le dictionnaire des mots-clefs et la methode a appeler
self.traitement = {
if ( self.DictMCVal.has_key( 'Type' ) ):
TypeAnalyse = self.DictMCVal[ 'Type' ]
- Traitement = None
+ traitement = None
subDict = {}
if ( self.traitement.has_key( TypeAnalyse ) ):
- (Traitement, subDict) = self.traitement[ TypeAnalyse ]
+ (traitement, subDict) = self.traitement[ TypeAnalyse ]
- if ( Traitement is not None ):
- self.texteSTD = apply( STDGenerateur.__dict__[ Traitement ], (self, subDict) )
+ if ( traitement is not None ):
+ self.texteSTD = apply( STDGenerateur.__dict__[ traitement ], (self, subDict) )
return self.texteSTD
if ( self.DictMCVal.has_key( 'Method' ) ):
Methode = self.DictMCVal[ 'Method' ]
- Traitement = None
+ traitement = None
if ( subDict.has_key( Methode ) ):
- Traitement = subDict[ Methode ]
+ traitement = subDict[ Methode ]
- if ( Traitement is not None ):
- txt += apply( STDGenerateur.__dict__[ Traitement ], (self,) )
+ if ( traitement is not None ):
+ txt += apply( STDGenerateur.__dict__[ traitement ], (self,) )
txt += self.MinMaxResult()
if ( self.DictMCVal.has_key( 'Method' ) ):
Methode = self.DictMCVal[ 'Method' ]
- Traitement = None
+ traitement = None
if ( subDict.has_key( Methode ) ):
- Traitement = subDict[ Methode ]
+ traitement = subDict[ Methode ]
- if ( Traitement is not None ):
+ if ( traitement is not None ):
txt += "# Etude 'Central Uncertainty'\n"
- txt += apply( STDGenerateur.__dict__[ Traitement ], (self,) )
+ txt += apply( STDGenerateur.__dict__[ traitement ], (self,) )
txt += self.Footer()
return txt
if ( self.DictMCVal.has_key( 'Method' ) ):
Methode = self.DictMCVal[ 'Method' ]
- Traitement = None
+ traitement = None
if ( subDict.has_key( Methode ) ):
- Traitement = subDict[ Methode ]
+ traitement = subDict[ Methode ]
- if ( Traitement is not None ):
- txt += apply( STDGenerateur.__dict__[ Traitement ], (self, subDict) )
+ if ( traitement is not None ):
+ txt += apply( STDGenerateur.__dict__[ traitement ], (self, subDict) )
txt += self.Footer()
return txt
if ( self.DictMCVal.has_key( 'Algorithm' ) ):
Algorithme = self.DictMCVal[ 'Algorithm' ]
- Traitement = None
+ traitement = None
if ( subDict.has_key( Algorithme ) ):
- Traitement = subDict[ Algorithme ]
+ traitement = subDict[ Algorithme ]
- if ( Traitement is not None ):
- txt = apply( STDGenerateur.__dict__[ Traitement ], (self,) )
+ if ( traitement is not None ):
+ txt = apply( STDGenerateur.__dict__[ traitement ], (self,) )
maxOuterSampling = None
if ( self.DictMCVal.has_key( 'MaximumOuterSampling' ) ):
if ( self.DictMCVal.has_key( 'OptimizationAlgorithm' ) ):
OptimizationAlgo = self.DictMCVal[ 'OptimizationAlgorithm' ]
- Traitement = None
+ traitement = None
if ( subDict.has_key( OptimizationAlgo ) ):
- Traitement = subDict[ OptimizationAlgo ]
+ traitement = subDict[ OptimizationAlgo ]
- if ( Traitement is not None ):
- txt += apply( STDGenerateur.__dict__[ Traitement ], (self,) )
+ if ( traitement is not None ):
+ txt += apply( STDGenerateur.__dict__[ traitement ], (self,) )
txt += self.OptimizerSettings()
txt += self.PhysicalStartingPoint()
if ( self.DictMCVal.has_key( 'Approximation' ) ):
Approximation = self.DictMCVal[ 'Approximation' ]
- Traitement = None
+ traitement = None
if ( subDict.has_key( Approximation ) ):
- Traitement = subDict[ Approximation ]
+ traitement = subDict[ Approximation ]
- if ( Traitement is not None ):
- txt += apply( STDGenerateur.__dict__[ Traitement ], (self,) )
+ if ( traitement is not None ):
+ txt += apply( STDGenerateur.__dict__[ traitement ], (self,) )
txt += self.RunAlgorithm()
txt += self.AnalyticalResult()
# Cette instruction genere le contenu du fichier de parametres pour le code Carmel3D
# si le jdc est valide (sinon cela n a pas de sens)
- if obj.isvalid() :
+ if obj.isValid() :
# constitution du bloc VERSION du fichier PHYS (existe toujours)
try :
self.generBLOC_VERSION(obj)
# constitution du bloc VERSION du fichier PHYS
# creation d une entite VERSION ; elle sera du type PROC car decrit ainsi
# dans le du catalogue
- version=obj.addentite('VERSION',pos=None)
+ version=obj.addEntite('VERSION',pos=None)
self.generPROC_ETAPE(obj.etapes[0])
self.texteCarmel3D+="["+obj.etapes[0].nom+"\n"
for cle in obj.etapes[0].valeur :
self.texteCarmel3D+=" "+cle+" "+str(obj.etapes[0].valeur[cle])+"\n"
self.texteCarmel3D+="]\n"
# destruction de l entite creee
- obj.suppentite(version)
+ obj.suppEntite(version)
#----------------------------------------------------------------------------------------
def generBLOC_MATERIALS(self) :
s=PythonGenerator.generMCSIMP(self,obj)
if hasattr(obj.etape,'sdnom'): clef=obj.etape.sdnom+"____"
else: clef=""
- for i in obj.get_genealogie() :
+ for i in obj.getGenealogie() :
clef=clef+"__"+i
self.dictMCVal[clef]=obj.valeur
# print 'generMCSIMP self.texteDico = ',self.texteDico
if hasattr(obj.etape,'sdnom'): clef=obj.etape.sdnom+"____"
else: clef=""
- for i in obj.get_genealogie() :
+ for i in obj.getGenealogie() :
clef=clef+"__"+i
self.dictMCVal[clef]=obj.valeur
Remplit le dictionnaire des MCSIMP si nous ne sommes ni dans une loi, ni dans une variable
"""
clef=""
- for i in obj.get_genealogie() :
+ for i in obj.getGenealogie() :
clef=clef+"__"+i
#self.dictMCVal[obj.nom]=obj.valeur
self.dictMCVal[clef]=obj.valeur
Methode particuliere pour les objets de type FORMULE
"""
l=[]
- nom = obj.get_nom()
+ nom = obj.getNom()
if nom == '' : nom = 'sansnom'
if len(obj.mc_liste)>0:
l.append(nom + ' = FORMULE(')
"IncrementMaxTemperature" : "DTPREC",
"ChoixExtractionTransitoires" : "CHOIEXTR",
"IncrementMaxTempsAffichage" : "DTARCH",
- "TraitementGeometrie" : "TYPEGEOM",
+ "traitementGeometrie" : "TYPEGEOM",
"RayonInterne" : "RINT",
"RayonInterne_mess" : "RINT_MESSAGE",
"RayonExterne" : "REXT",
"IncrementMaxTemperature" : "increment max de temp/noeud/instant (degC)",
"ChoixExtractionTransitoires" : "choix d'extraction de transitoires de temp et contraintes",
"IncrementMaxTempsAffichage" : "increment max de temps pour affichage (s)",
- "TraitementGeometrie" : "traitement de la geometrie de la cuve : {GEOMETRIE, MAILLAGE}",
+ "traitementGeometrie" : "traitement de la geometrie de la cuve : {GEOMETRIE, MAILLAGE}",
"RayonInterne" : "rayon interne (m)",
"RayonInterne_mess" : "affichage ecran du rayon interne (m)",
"RayonExterne" : "rayon externe (m)",
"IncrementMaxTemperature" : "0.1",
"ChoixExtractionTransitoires" : "NON",
"IncrementMaxTempsAffichage" : "1000.",
- "TraitementGeometrie" : "GEOMETRIE",
+ "traitementGeometrie" : "GEOMETRIE",
"RayonInterne" : "1.994",
"RayonInterne_mess" : "NON",
"RayonExterne" : "2.2015",
"IncrementMaxTemperature" : "OPTIONS",
"ChoixExtractionTransitoires" : "OPTIONS",
"IncrementMaxTempsAffichage" : "OPTIONS",
- "TraitementGeometrie" : "DONNEES DE LA CUVE",
+ "traitementGeometrie" : "DONNEES DE LA CUVE",
"RayonInterne" : "DONNEES DE LA CUVE",
"RayonInterne_mess" : "DONNEES DE LA CUVE",
"RayonExterne" : "DONNEES DE LA CUVE",
def generMCSIMP(self,obj) :
self.dico_mot[obj.nom]=obj.valeur
clef=""
- for i in obj.get_genealogie() :
+ for i in obj.getGenealogie() :
clef=clef+"_"+i
self.dico_genea[clef]=obj.valeur
s=PythonGenerator.generMCSIMP(self,obj)
# Rubrique DONNEES DE LA CUVE
self.texteCuve += self.rubrique('DONNEES DE LA CUVE')
- if self.dico_mot.has_key('TraitementGeometrie'):
- self.texteCuve += self.affecteValeur('TraitementGeometrie', self.valeurproposee[str(self.dico_mot["TraitementGeometrie"])])
- if str(self.dico_mot["TraitementGeometrie"])=='Topologie':
+ if self.dico_mot.has_key('traitementGeometrie'):
+ self.texteCuve += self.affecteValeur('traitementGeometrie', self.valeurproposee[str(self.dico_mot["traitementGeometrie"])])
+ if str(self.dico_mot["traitementGeometrie"])=='Topologie':
self.texteCuve+="# - si MAILLAGE, fournir NBNO et liste des abscisses (m)"+"\n"
self.texteCuve+="# - si GEOMETRIE, fournir (RINT, RINT_MESSAGE),"+"\n"
self.texteCuve+="# (REXT, REXT_MESSAGE),"+"\n"
self.texteCuve += self.ecritVariable('LigamentExterneMin_mess')
self.texteCuve+="#"+"\n"
self.texteCuve += self.ecritVariable('NombreNoeudsMaillage')
- if str(self.dico_mot["TraitementGeometrie"])=='Maillage':
+ if str(self.dico_mot["traitementGeometrie"])=='Maillage':
self.texteCuve+="# - si MAILLAGE, fournir NBNO et liste des abscisses (m)"+"\n"
self.texteCuve+="# - si GEOMETRIE, fournir (RINT, RINT_MESSAGE),"+"\n"
self.texteCuve+="# (REXT, REXT_MESSAGE),"+"\n"
self.texteCuve += self.ecritVariable('NombreNoeudsMaillage')
self.imprime(1,(self.dico_mot["ListeAbscisses"]))
else :
- self.texteCuve += self.affecteValeurDefaut('TraitementGeometrie')
+ self.texteCuve += self.affecteValeurDefaut('traitementGeometrie')
self.texteCuve+="# - si MAILLAGE, fournir NBNO et liste des abscisses (m)"+"\n"
self.texteCuve+="# - si GEOMETRIE, fournir (RINT, RINT_MESSAGE),"+"\n"
self.texteCuve+="# (REXT, REXT_MESSAGE),"+"\n"
"""
short_keyword = obj.nom.strip()
long_keyword = ""
- for i in obj.get_genealogie()[:-1]:
+ for i in obj.getGenealogie()[:-1]:
long_keyword += i + "."
long_keyword += short_keyword
self.kw_dict[short_keyword] = obj.valeur
def genereXML(self):
print "IDM: genereXML dans generator_openturns_wrapper.py"
- #print "appli.CONFIGURATION=",self.appli.CONFIGURATION.__dict__
+ #print "appli.maConfiguration=",self.appli.maConfiguration.__dict__
if self.listeFichiers != [] :
self.dictMCVal["Files"]=self.listeFichiers
print "dictMCVal", self.dictMCVal, "dictVariables", self.dictVariables
Méthode particulière pour les objets de type FORMULE
"""
l=[]
- nom = obj.get_nom()
+ nom = obj.getNom()
if nom == '' : nom = 'sansnom'
l.append(nom + ' = FORMULE(')
for v in obj.mc_liste:
