# Modules Eficas
import prefs
+name='prefs_'+prefs.code
+__import__(name)
+
from InterfaceTK import eficas_go
eficas_go.lance_eficas(code=prefs.code)
l.sort()
return l
+ def get_variables_avant(self,etape):
+ # voir le sort avec IDM
+ d=self.get_contexte_avant(etape)
+ l=[]
+ for k,v in d.items():
+ if str(type(v)).find('variable') > -1 :
+ l.append(k)
+ l.sort()
+ return l
+
def get_sd_avant_du_bon_type_pour_type_de_base(self,etape,type):
"""
Retourne la liste des concepts avant etape d'1 type de base acceptable
# Traitement d'un flottant isolé
txt = str(self.valeur)
clefobj=self.GetNomConcept()
- if self.jdc.appli.dict_reels.has_key(clefobj):
- if self.jdc.appli.dict_reels[clefobj].has_key(self.valeur):
- txt=self.jdc.appli.dict_reels[clefobj][self.valeur]
+ if self.jdc.appli.appliEficas.dict_reels.has_key(clefobj):
+ if self.jdc.appli.appliEficas.dict_reels[clefobj].has_key(self.valeur):
+ txt=self.jdc.appli.appliEficas.dict_reels[clefobj][self.valeur]
elif type(self.valeur) in (types.ListType,types.TupleType) :
# Traitement des listes
txt='('
for val in self.valeur:
if type(val) == types.FloatType :
clefobj=self.GetNomConcept()
- if self.jdc.appli.dict_reels.has_key(clefobj):
- if self.jdc.appli.dict_reels[clefobj].has_key(val):
- txt=txt + sep +self.jdc.appli.dict_reels[clefobj][val]
+ if self.jdc.appli.appliEficas.dict_reels.has_key(clefobj):
+ if self.jdc.appli.appliEficas.dict_reels[clefobj].has_key(val):
+ txt=txt + sep +self.jdc.appli.appliEficas.dict_reels[clefobj][val]
else :
txt=txt + sep + str(val)
else :
val=self.valeur
if type(val) == types.FloatType :
clefobj=self.GetNomConcept()
- if self.jdc.appli.dict_reels.has_key(clefobj):
- if self.jdc.appli.dict_reels[clefobj].has_key(val):
- return self.jdc.appli.dict_reels[clefobj][val]
+ if self.jdc.appli.appliEficas.dict_reels.has_key(clefobj):
+ if self.jdc.appli.appliEficas.appliEficas.dict_reels[clefobj].has_key(val):
+ return self.jdc.appli.appliEficas.dict_reels[clefobj][val]
if type(val) != types.TupleType :
try:
return val.get_name()
texte = f.read()
f.close()
from desVisu import DVisu
- monVisu=DVisu(parent=self.editor,fl=Qt.WType_Dialog)
- monVisu.TB.setText(texte)
- monVisu.show()
+ monVisuDialg=DVisu(parent=self.editor.appliEficas,fl=0)
+ monVisuDialg.TB.setText(texte)
+ monVisuDialg.show()
+
class INCLUDE_MATERIAUTreeItem(INCLUDETreeItemBase):
itemNode=MATERIAUNode
# Attention l ordre des if est important
+ if self.item.wait_matrice ():
+ from monMatricePanel import MonMatricePanel
+ klass=MonMatricePanel
# l'objet prend sa (ses) valeur(s) dans un ensemble discret de valeurs
- if self.item.has_into():
+ elif self.item.has_into():
if self.item.is_list() :
from monPlusieursIntoPanel import MonPlusieursIntoPanel
klass = MonPlusieursIntoPanel
is_a_list= self.definition.validators.is_list() * is_a_list
return is_a_list
- #def get_into(self,liste_courante=None):
- # """
- # Cette méthode retourne la liste de choix proposée par le mot cle. Si le mot cle ne propose
- # pas de liste de choix, la méthode retourne None.
- # L'argument d'entrée liste_courante, s'il est différent de None, donne la liste des choix déja
- # effectués par l'utilisateur. Dans ce cas, la méthode get_into doit calculer la liste des choix
- # en en tenant compte.
- # Cette méthode part du principe que la relation entre into du mot clé et les validateurs est
- # une relation de type ET (AndVal).
- # """
- # if not self.object.definition.validators :
- # return self.object.definition.into
- # else:
- # return self.object.definition.validators.get_into(liste_courante,self.definition.into)
def has_into(self):
"""
def wait_tuple(self):
""" Méthode booléenne qui retourne 1 si l'objet pointé par self
- attend un shell, 0 sinon """
+ attend un Tuple, 0 sinon """
for ss_type in self.object.definition.type:
if repr(ss_type).find('Tuple') != -1 :
return 1
return 0
+ def wait_matrice(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:
+ if repr(ss_type).find('Matrice') != -1 :
+ return 1
+ return 0
+
def wait_assd(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 """
import qtCommun
-VERSION_EFICAS = "EFICAS v1.16"
class JDCEditor(QSplitter):
self.code = self.appliEficas.CONFIGURATION.code
self.version_code = VERSION_CODE
- self.titre=VERSION_EFICAS + ' pour '+ self.code
+ self.titre=self.appliEficas.VERSION_EFICAS + ' pour '+ self.code
self.dict_reels={}
self.liste_simp_reel=[]
# Il faut convertir le contenu du fichier en fonction du format
if convert.plugins.has_key( self.appliEficas.format_fichier ):
# Le convertisseur existe on l'utilise
- appli = self
+ #appli = self
p=convert.plugins[self.appliEficas.format_fichier]()
p.readfile(fn)
- text=p.convert('exec',appli)
+ text=p.convert('exec',self.appliEficas)
if not p.cr.estvide():
self.affiche_infos("Erreur à la conversion")
else :
from PyQt4 import *
from PyQt4.QtGui import *
+from PyQt4.QtCore import *
import os
if version == "V8V9" :
from Traducteur import traduitV8V9
suffixe="v9.comm"
- fn = QFileDialog.getOpenFileName( QString(directPath) , "")
+ fn = QFileDialog.getOpenFileName(
+ editor.appliEficas,
+ editor.appliEficas.trUtf8('Traduire Fichier'),
+ QString(directPath) ,
+ editor.appliEficas.trUtf8('JDC Files (*.comm);;''All Files (*)'))
FichieraTraduire=str(fn)
if (FichieraTraduire == "" or FichieraTraduire == () ) : return
except :
pass
- from desVisu import DVisu
+ from monVisu import DVisu
titre = "conversion de "+ FichieraTraduire
- monVisu=DVisu(parent=editor,fl=Qt.WType_Dialog)
- monVisu.setCaption(titre)
- monVisu.TB.setText(texte)
- monVisu.show()
+ monVisuDialg=DVisu(parent=editor.appliEficas,fl=0)
+ monVisuDialg.setWindowTitle(titre)
+ monVisuDialg.TB.setText(texte)
+ monVisuDialg.show()
listeValeurs=self.node.item.GetListeValeurs()
if self.node.item.wait_tuple()== 1 :
listeATraiter=listeValeurs
+ for valeur in listeATraiter:
+ str_valeur=str(valeur)
+ self.LBValeurs.addItem(str_valeur)
else :
- listeATraiter=self.DecoupeListeValeurs(listeValeurs)
- for valeur in listeATraiter:
- str_valeur=str(valeur)
- self.LBValeurs.addItem(str_valeur)
+ for valeur in self.DecoupeListeValeurs(listeValeurs):
+ if type(valeur) == types.TupleType:
+ TupleEnTexte="("
+ for val in valeur :
+ TupleEnTexte = TupleEnTexte + str(self.politique.GetValeurTexte(val)) +", "
+ TupleEnTexte = TupleEnTexte[0:-2] +")"
+ print TupleEnTexte
+ self.LBValeurs.addItem(TupleEnTexte)
+ else :
+ self.LBValeurs.addItem(QString(str(valeur)))
+
def Ajout1Valeur(self,liste=[]):
# Pour être appele a partir du Panel Importer (donc plusieurs fois par AjouterNValeur)
+ validite=1
if liste == [] :
if self.node.item.wait_tuple()== 1 :
liste=SaisieValeur.TraiteLEValeurTuple(self)
if liste == [''] : return
- validite=1
else :
liste,validite=SaisieValeur.TraiteLEValeur(self)
- else :
- validite=1
- if validite == 0 : return
+ if validite == 0 : return
if liste ==[] : return
if len(liste) != self.nbValeurs :
if self.node.item.wait_tuple()== 1 :
liste2=tuple(liste)
liste=liste2
+
index=self.LBValeurs.currentRow()
if ((self.LBValeurs.isItemSelected(self.LBValeurs.item(index )) == 0) and (index > 0 )):
index=0
else :
index=self.LBValeurs.currentRow() + 1
indexListe=index*self.nbValeurs
- if index == 0 :
- indexListe=len(self.listeValeursCourantes)
+ if index == 0 : indexListe=len(self.listeValeursCourantes)
+
listeVal=[]
for valeur in self.listeValeursCourantes :
listeVal.append(valeur)
else :
listeATraiter=self.DecoupeListeValeurs(listeRetour)
for valeur in listeATraiter :
- str_valeur=str(valeur)
+ if type(valeur) == types.TupleType:
+ TupleEnTexte="("
+ for val in valeur :
+ TupleEnTexte = TupleEnTexte + str(self.politique.GetValeurTexte(val)) +", "
+ str_valeur = TupleEnTexte[0:-2] +")"
+ else :
+ str_valeur=str(valeur)
self.LBValeurs.insertItem(index,str_valeur)
item=self.LBValeurs.item(index)
item.setSelected(1)
self.connecterSignaux()
def connecterSignaux(self):
- self.connect(self.BOk,SIGNAL("clicked()"),self.BAjoutClicked)
self.connect(self.bAjout,SIGNAL("clicked()"),self.BAjoutClicked)
-
def BAjoutClicked(self):
self.node.treeParent.append_child(self.node.item.get_nom())
self.connecterSignaux()
QTPanel.__init__(self,node,parent)
QTPanelTBW2.__init__(self,node,parent,racine=1)
- self.a=0
+ self.LEFiltre.setFocus()
+
def connecterSignaux(self):
self.connect(self.LBNouvCommande,SIGNAL("doubleClicked(QListBoxItem*)"),self.LBNouvCommandeClicked)
if val != '' and val != ' ' and val != self.separateur :
val=str(val)
try :
- val=eval(val,{})
+ val2=eval(val,{})
+ liste.append(val)
except :
pass
- liste.append(val)
self.FonctPanel.AjoutNValeur(liste)
self.InitCommentaire()
self.detruitBouton()
self.connecterSignaux()
+ self.lineEditVal.setFocus()
def connecterSignaux(self) :
self.connect(self.bOk,SIGNAL("clicked()"),self.BOk2Pressed)
--- /dev/null
+# -*- coding: utf-8 -*-
+# CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2002 EDF R&D WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
+# (AT YOUR OPTION) ANY LATER VERSION.
+#
+# THIS PROGRAM 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
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+#
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
+# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
+#
+#
+# ======================================================================
+# Modules Python
+# Modules Eficas
+
+from desVisu import Ui_DVisu
+from PyQt4 import *
+from PyQt4.QtCore import *
+from PyQt4.QtGui import *
+
+# Import des panels
+
+class DVisu(Ui_DVisu ,QtGui.QDialog):
+ """
+ Classe définissant le panel associé aux mots-clés qui demandent
+ à l'utilisateur de choisir une seule valeur parmi une liste de valeurs
+ discrètes
+ """
+ def __init__(self,parent = None , name = None,fl = 0):
+ QtGui.QDialog.__init__(self,parent)
+ self.setModal(True)
+ self.setupUi(self)
+
+ def on_buttonCancel_clicked(self):
+ QDialog.reject(self)
+
+ def on_buttonOk_clicked(self):
+ QDialog.accept(self)
+
if str(clef) != str(texteValeur) :
self.node.item.object.init_modif()
clefobj=self.node.item.object.GetNomConcept()
- if not self.parent.dict_reels.has_key(clefobj):
- self.parent.dict_reels[clefobj] = {}
- self.parent.dict_reels[clefobj][clef]=texteValeur
- self.parent.dict_reels[clefobj]
+ if not self.parent.appliEficas.dict_reels.has_key(clefobj):
+ self.parent.appliEficas.dict_reels[clefobj] = {}
+ self.parent.appliEficas.dict_reels[clefobj][clef]=texteValeur
+ self.parent.appliEficas.dict_reels[clefobj]
+ if clefobj=="" :
+ if not self.parent.appliEficas.dict_reels.has_key(self.node.item.object.etape) :
+ self.parent.appliEficas.dict_reels[self.node.item.object.etape] = {}
+ self.parent.appliEficas.dict_reels[self.node.item.object.etape][clef]=texteValeur
self.node.item.object.fin_modif()
except:
pass
valeurTexte=valeur
if "R" in self.node.item.object.definition.type:
clefobj=self.node.item.object.GetNomConcept()
- if self.parent.dict_reels.has_key(clefobj):
- if self.parent.dict_reels[clefobj].has_key(valeur):
- valeurTexte=self.parent.dict_reels[clefobj][valeur]
+ if self.parent.appliEficas.dict_reels.has_key(clefobj):
+ if self.parent.appliEficas.dict_reels[clefobj].has_key(valeur):
+ valeurTexte=self.parent.appliEficas.dict_reels[clefobj][valeur]
return valeurTexte
+ def AjoutDsDictReel(self,texteValeur):
+ try :
+ if "R" in self.node.item.object.definition.type:
+ if str(texteValeur)[0] != "'":
+ clef=eval(texteValeur)
+ if str(clef) != str(texteValeur) :
+ clefobj=self.node.item.object.GetNomConcept()
+ if not self.parent.appliEficas.dict_reels.has_key(clefobj):
+ self.parent.appliEficas.dict_reels[clefobj] = {}
+ self.parent.appliEficas.dict_reels[clefobj][clef]=texteValeur
+ if clefobj=="" :
+ if not self.parent.appliEficas.dict_reels.has_key(self.node.item.object.etape) :
+ self.parent.appliEficas.dict_reels[self.node.item.object.etape] = {}
+ self.parent.appliEficas.dict_reels[self.node.item.object.etape][clef]=texteValeur
+
+ except:
+ #else :
+ #print "pb ds try de AjoutDsDictReel"
+ pass
+
+ def AjoutDsDictReelEtape(self):
+ print self.parent.appliEficas.dict_reels
+ print self.node.item.object
+ try:
+ if self.parent.appliEficas.dict_reels.has_key(self.node.item.object) :
+ self.parent.appliEficas.dict_reels[self.node.item.sdnom]=self.parent.appliEficas.dict_reels[self.node.item.object]
+ del self.parent.appliEficas.dict_reels[self.node.item.object]
+ except :
+ pass
+
+
#------------------------------------
class PolitiqueUnique(Validation) :
#------------------------------------
return validite, commentaire
-#------------------------
-class PolitiquePlusieurs:
-#------------------------
+#--------------------------------------
+class PolitiquePlusieurs(Validation):
+#--------------------------------------
"""
classe servant pour les entrees ne demandant qu un mot clef
"""
commentaire="Nouvelle valeur acceptée"
commentaire2=""
valide=1
+ if listevaleur==None: return
+ if listevaleur=="": return
if not( type(listevaleur) in (types.ListType,types.TupleType)) :
listevaleur=tuple(listevaleur)
for valeur in listevaleur :
# On teste le type de la valeur
+ valeurScientifique=valeur
valide=self.node.item.valide_item(valeur)
if not valide :
- #print self.__class__
- #if not testtype :
try :
valeur,valide=self.node.item.eval_valeur(valeur)
valide,commentaire = self.node.item.object.verif_type(valeur)
commentaire="La liste a déjà atteint le nombre maximum d'éléments,ajout refusé"
return valide,commentaire,commentaire2,listeRetour
if len(listecourante) + 1 > min :
+ commentaire=""
return valide,commentaire,commentaire2,listeRetour
# On ajoute la valeur testee a la liste courante et a la liste acceptee
+ self.AjoutDsDictReel(valeurScientifique)
listecourante.insert(index,valeur)
index=index+1
listeRetour.append(valeur)
self.editor = parent
self.node = node
self.BuildLBNouvCommande()
+ self.LEFiltre.setFocus()
self.NbRecherches = 0
if racine == 1 :
self.AppelleBuildLBRegles()
def handleCurrentChanged(self):
try :
- self.LEFiltre.setFocus()
+ self.LEFiltre.setFocus()
except :
- pass
+ pass
def BuildLBNouvCommande(self):
if nom == '' : return # si pas de nom, on ressort sans rien faire
self.editor.init_modif()
test,mess = self.node.item.nomme_sd(nom)
+ #Notation scientifique
+ from politiquesValidation import Validation
+ validation=Validation(self.node,self.editor)
+ validation.AjoutDsDictReelEtape()
self.editor.affiche_infos(mess)
# ------------------------------- #
"""
Constructor
"""
+ print self
+ self.VERSION_EFICAS="Eficas QT4 V1.17"
self.ihm="QT"
self.code=code
self.salome=salome
self.top = self #(pour CONFIGURATION)
self.QWParent=None #(Pour lancement sans IHM)
self.indice=0
+ self.dict_reels={}
import prefs
if salome :
self.REPINI=prefsCode.REPINI
self.RepIcon=prefsCode.INSTALLDIR+"/Editeur/icons"
+ self.INSTALLDIR=prefsCode.INSTALLDIR
self.CONFIGURATION = configuration.make_config(self,prefsCode.REPINI)
self.CONFIGStyle = configuration.make_config_style(self,prefsCode.REPINI)
if hasattr(prefsCode,'encoding'):
self.connecterSignaux()
- #self.monAssistant=QAssistantClient(QString(""), self.viewmanager)
#if self.salome :
# from Editeur import session
# self.ouvreFichiers()
self.initRecents()
self.ouvreFichiers()
+ self.setWindowTitle(self.VERSION_EFICAS)
def OPENTURNS(self) :
self.MenuBar.removeItem(5)
self.connect(self.actionFermer_tout,SIGNAL("activated()"),self.fileCloseAll)
self.connect(self.actionQuitter,SIGNAL("activated()"),self.fileExit)
+ self.connect(self.actionEficas,SIGNAL("activated()"),self.aidePPal)
+ self.connect(self.actionVersion,SIGNAL("activated()"),self.version)
+
self.connect(self.actionCouper,SIGNAL("activated()"),self.editCut)
self.connect(self.actionCopier,SIGNAL("activated()"),self.editCopy)
self.connect(self.actionColler,SIGNAL("activated()"),self.editPaste)
#self.connect(self.helpIndexAction,SIGNAL("activated()"),self.helpIndex)
#self.connect(self.helpContentsAction,SIGNAL("activated()"),self.helpContents)
- #self.connect(self.helpAboutAction,SIGNAL("activated()"),self.helpAbout)
- #self.connect(self.aidenew_itemAction,SIGNAL("activated()"),self.helpAbout)
def ouvreFichiers(self) :
traduction(self.CONFIGURATION.rep_user,self.viewmanager,"V8V9")
def version(self) :
- from desVisu import DVisu
+ from monVisu import DVisu
titre = "version "
- monVisu=DVisu(parent=self.viewmanager)
- monVisu.setCaption(titre)
- monVisu.TB.setText("Eficas V1.13")
- monVisu.adjustSize()
- monVisu.show()
+ monVisuDialg=DVisu(parent=self,fl=0)
+ monVisuDialg.setWindowTitle(titre)
+ monVisuDialg.TB.setText(self.VERSION_EFICAS +QString(" pour ") + self.code)
+ monVisuDialg.adjustSize()
+ monVisuDialg.show()
def aidePPal(self) :
- maD=INSTALLDIR+"/AIDE/fichiers"
- docsPath = QDir(maD).absPath()
- self.monAssistant.showPage( QString("%1/index.html").arg(docsPath) )
+ maD=self.INSTALLDIR+"/Aide"
+ docsPath = QDir(maD).absolutePath()
+ monAssistant=QAssistantClient(QString(""), self)
+ arguments=QStringList()
+ arguments << "-profile" <<docsPath+QDir.separator()+QString("eficas_")+QString(self.code)+QString(".adp");
+ monAssistant.setArguments(arguments);
+ monAssistant.showPage(docsPath+QDir.separator()+QString("fichiers_"+QString(self.code)+QString("/index.html")))
def optionEditeur(self) :
from monOptionsEditeur import Options
def fileExit(self):
# On peut sortir sur Abort
- self.viewmanager.handleCloseAll()
- if self.salome :
- self.close()
- else :
- qApp.closeAllWindows()
+ res=self.viewmanager.handleCloseAll()
+ if (res != 2) :
+ if self.salome :
+ self.close()
+ else :
+ qApp.closeAllWindows()
def editCopy(self):
self.viewmanager.handleEditCopy()
def visuJdcPy(self):
self.viewmanager.handleViewJdcPy()
- def helpAbout(self):
- import AIDE
- AIDE.go3(parent=self)
def NewInclude(self):
self.viewmanager.newIncludeEditor()
for valeur in lChoix :
self.listBoxVal.addItem( str(valeur) )
if len(lChoix) == 1 :
- self.listBoxVal.setCurrentRow(1)
+ self.listBoxVal.setCurrentRow(0)
+ self.listBoxVal.item(0).setSelected(1)
def ClicASSD(self):
if self.listBoxASSD.currentItem()== None : return
from PyQt4.QtGui import *
from PyQt4.QtCore import *
-VERSION_EFICAS="Eficas V1.16"
class READERCATA:
def __init__(self,QWParent, appliEficas):
self.QWParent=QWParent
self.appliEficas=self.QWParent.appliEficas
+ print self.appliEficas
+ self.VERSION_EFICAS=self.appliEficas.VERSION_EFICAS
self.code=self.QWParent.code
self.appliEficas.format_fichier='python'
if hasattr(self.appliEficas,'mode_nouv_commande'):
self.version_code = liste_cata_possibles[0][1]
self.appliEficas.format_fichier=liste_cata_possibles[0][3]
lab=QString("Eficas V1.")
- lab+=QString(VERSION_EFICAS)
+ lab+=QString(self.VERSION_EFICAS)
lab+=QString(" pour ")
lab+=QString(self.code)
lab+=QString(" avec le catalogue ")
#
self.traite_clefs_documentaires()
self.cata=(self.cata,)
- titre=VERSION_EFICAS + " avec le catalogue " + os.path.basename(self.fic_cata)
+ titre=self.VERSION_EFICAS + " avec le catalogue " + os.path.basename(self.fic_cata)
if self.appliEficas.top:
self.appliEficas.setWindowTitle(titre)
self.appliEficas.titre=titre
liste_choix = self.dico_catalogues.keys()
liste_choix.sort()
- lab=QString(VERSION_EFICAS)
+ lab=QString(self.VERSION_EFICAS)
lab+=QString(" pour ")
lab+=QString(self.code)
lab+=QString(" avec le catalogue ")
widgetChoix=MonChoixCata(liste_choix,self, self.appliEficas, "", True )
ret=widgetChoix.exec_()
- lab=QString(VERSION_EFICAS)
+ lab=QString(self.VERSION_EFICAS)
lab+=QString(" pour ")
lab+=QString(self.code)
lab+=QString(" avec le catalogue ")
self.paramMenu.addAction(self.ParamApres)
self.paramMenu.addAction(self.ParamAvant)
self.menu.addAction(self.Documentation)
+ self.menu.removeAction(self.Supprime)
+ self.menu.addAction(self.Supprime)
#-----------------------------------------#
self.tree.connect(self.Commente,SIGNAL("activated()"),self.Commenter)
self.Commente.setStatusTip("commente le noeud ")
self.commentMenu.addAction(self.Commente)
+ self.menu.removeAction(self.Supprime)
+ self.menu.addAction(self.Supprime)
def Commenter(self):
item= self.tree.currentItem()
maPage=self.getEditor( fichier,units=units)
def handleClose(self,doitSauverRecent = 1):
- #print "passage dans handleClose"
- #print self.dict_editors
if doitSauverRecent : self.appliEficas.sauveRecents()
index=self.myQtab.currentIndex()
if index < 0 : return
- self.checkDirty(self.dict_editors[index])
+ res=self.checkDirty(self.dict_editors[index])
+ if res == 2 : return 2 # l utilisateur a annule
index=self.myQtab.currentIndex()
idx=index
while idx < len(self.dict_editors) -1 :
del self.doubles[self.dict_editors[index]]
except :
pass
- print self.dict_editors
self.myQtab.removeTab(index)
+ return res
def handleCloseAll(self):
+ res=0
self.appliEficas.sauveRecents()
- #print "passage dans CloseAll"
- print "self.dict_editors", self.dict_editors
while len(self.dict_editors) > 0 :
self.myQtab.setCurrentIndex(0)
- self.handleClose(0)
+ res=self.handleClose(0)
+ if res==2 : return res # l utilsateur a annule
+ return res
def handleEditCopy(self):
#print "passage dans handleEditCopy"
editor.handleEditPaste()
def newEditor(self,include=0):
- #print "passage dans newEditor"
maPage=self.getEditor()
def newIncludeEditor(self):
@param editor editor window to check
@return flag indicating successful reset of the dirty flag (boolean)
"""
-
- print "checkDirty"
+ res=1
if (editor.modified) and (editor in self.doubles.keys()) :
res = QMessageBox.warning(
None,
fn = self.appliEficas.trUtf8('Noname')
res = QMessageBox.warning(self.appliEficas,
self.appliEficas.trUtf8("Fichier Modifie"),
- self.appliEficas.trUtf8("Le fichier <b>%1</b> n a pas ete sauvegarde.")
- .arg(fn),
+ self.appliEficas.trUtf8("Le fichier <b>%1</b> n a pas ete sauvegarde.") .arg(fn),
self.appliEficas.trUtf8("&Sauvegarder"),
self.appliEficas.trUtf8("&Quitter "),
- self.appliEficas.trUtf8("&Annuler"), 0, 2)
+ self.appliEficas.trUtf8("&Annuler") )
if res == 0:
(ok, newName) = editor.saveFile()
if ok:
index=self.myQtab.currentIndex()
self.myQtab.setTabText(index,fileName)
return ok
- elif res == 2:
- return 0
- return 1
-
+ return res
# Modules Eficas
import splash
import prefs
+name='prefs_'+prefs.code
+prefsCode=__import__(name)
import styles
from styles import style
import fontes
self.salome=salome
self.top=master
self.top.protocol("WM_DELETE_WINDOW",self.exitEFICAS)
+ self.appliEficas=self
#dimensionnement de la fenetre principale
#aspect ratio de l'ecran
if (self.test == 0):
splash._splash.configure(text = "Chargement des paramètres utilisateur")
import configuration
- self.CONFIGURATION = configuration.make_config(self,prefs.REPINI)
- self.CONFIGStyle = configuration.make_config_style(self,prefs.REPINI)
+ self.CONFIGURATION = configuration.make_config(self,prefsCode.REPINI)
+ self.CONFIGStyle = configuration.make_config_style(self,prefsCode.REPINI)
def cree_composants_graphiques(self):
"""
# Modules Eficas
import splash
import prefs
+name='prefs_'+prefs.code
+prefsCode=__import__(name)
import convert
import generator
import AIDE
('Help24',"view_doc","Documentation de l'objet courant",'jdc')
)
try:
- menu_defs=prefs.menu_defs['bureau']
+ menu_defs=prefsCode.menu_defs['bureau']
except:
pass
try:
- button_defs=prefs.button_defs['bureau']
+ button_defs=prefsCode.button_defs['bureau']
except:
pass
from Editeur import import_code
from Editeur import session
import prefs
+name='prefs_'+prefs.code
+prefsCode=__import__(name)
import convert
import generator
import string
self.top=None
self.test=2
import configuration
- self.CONFIGURATION=configuration.make_config(self,prefs.REPINI)
+ self.CONFIGURATION=configuration.make_config(self,prefsCode.REPINI)
self.load_readercata()
self.cata=self.readercata.cata
# Modules Eficas
from Editeur import Objecttreeitem
-import prefs
import panels
import images
from widgets import ListeChoix
class EFICAS(appli.APPLI):
try:
- from prefs import appli_composants
+ import prefs
+ name='prefs_'+prefs.code
+ prefsCode=__import__(name)
+ from prefsCode import appli_composants
except:
appli_composants=['readercata','bureau','browser','options']
# Modules Eficas
import prefs
-if hasattr(prefs,'encoding'):
+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)
+ sys.setdefaultencoding(prefsCode.encoding)
del sys.setdefaultencoding
# Fin hack
# Modules Eficas
import prefs
+name='prefs_'+prefs.code
+prefsCode=__import__(name)
import fontes
class FAQ:
buttons=('Lu',),
title="FAQs et limitations d'EFICAS",
command = self.lu_FAQ)
- txt = open(os.path.join(prefs.INSTALLDIR,'Editeur','faqs.txt'),'r').read()
+ txt = open(os.path.join(prefsCode.INSTALLDIR,'Editeur','faqs.txt'),'r').read()
Texte = Pmw.ScrolledText(self.Dialog.interior(),
text_font=fontes.standard)
Texte.insert(END,txt)
# Modules Eficas
from Editeur import Objecttreeitem
-import prefs
import panels
import images
from widgets import ListeChoix
try:
import prefs
- ICONDIR=prefs.ICONDIR
+ name='prefs_'+prefs.code
+ prefsCode=__import__(name)
+ ICONDIR=prefsCode.ICONDIR
except:
# Par defaut on utilise le repertoire local icons
ICONDIR=os.path.join(os.path.abspath(os.path.dirname(__file__)),'/Editeur/icons')
self.init()
try:
- from prefs import labels
+ import prefs
+ name='prefs_'+prefs.code
+ from prefsCode import labels
except:
labels= ('Fichier','Edition','Jeu de commandes','Catalogue','Options','Aide','Traduction')
from widgets import ListeChoix, showerror
from widgets import ListeChoixParGroupes
import prefs
+name='prefs_'+prefs.code
+prefsCode=__import__(name)
import options
SEPARATEUR = '-'*30
texte_infos = ''
for e in cmd.entites.keys() :
if e == name :
- texte_infos=getattr(cmd.entites[e],prefs.lang)
+ texte_infos=getattr(cmd.entites[e],prefsCode.lang)
break
if texte_infos == '' : texte_infos="Pas d'infos disponibles"
self.parent.appli.affiche_infos(texte_infos)
def selectCmd(self,name):
""" On retrouve la commande sous le curseur pour affichage du fr """
if name != 'COMMENTAIRE' and name != SEPARATEUR:
- texte_infos=getattr(self.parent.jdc.get_cmd(name),prefs.lang)
+ texte_infos=getattr(self.parent.jdc.get_cmd(name),prefsCode.lang)
self.parent.appli.affiche_infos(texte_infos)
def defCmd(self,name):
# Modules Eficas
from Editeur import Objecttreeitem
-import prefs
import panels
import images
from widgets import ListeChoix
# Modules Eficas
from Editeur import Objecttreeitem
-import prefs
import panels
import images
from widgets import showinfo
# Modules Eficas
from Editeur import Objecttreeitem
-import prefs
import panels
import images
from widgets import ListeChoix
# Modules Eficas
from Editeur import Objecttreeitem
-import prefs
import panels
import images
from widgets import ListeChoix
# Modules Eficas
from Editeur import Objecttreeitem
-#import prefs
#import panels
#import images
#from widgets import ListeChoix
# -*- coding: utf-8 -*-
import os
import prefs
+name='prefs_'+prefs.code
+prefsCode=__import__(name)
import basestyle
from basestyle import STYLE,style
-inistylefile=os.path.join(prefs.REPINI,"style.py")
+inistylefile=os.path.join(prefsCode.REPINI,"style.py")
if os.path.isfile(inistylefile):
execfile(inistylefile)
# Modules Eficas
from Editeur import Objecttreeitem
-import prefs
import panels
import images
from widgets import ListeChoix
# Modules Eficas
from Editeur import Objecttreeitem
-import prefs
import panels
import images
from widgets import FenetreDeParametre
# Modules Eficas
from Editeur import Objecttreeitem
-import prefs
import panels
import images
from widgets import ListeChoix
# Modules Eficas
from Editeur import Objecttreeitem
-import prefs
import panels
import images
from widgets import ListeChoix
# Modules Eficas
from Editeur import Objecttreeitem
-import prefs
import panels
import images
from widgets import ListeChoix
# Modules Eficas
from Editeur import Objecttreeitem
-import prefs
import panels
import images
from widgets import ListeChoix
if type(obj)==types.StringType:return obj
elif type(type_permis) == types.ClassType or isinstance(type_permis,type):
if self.is_object_from(obj,type_permis):return obj
+ elif type_permis == 'Fichier' :
+ import os
+ if os.path.isfile(obj):return obj
+ else : raise ValError("%s n'est pas un fichier valide" % repr(obj))
elif type(type_permis) == types.InstanceType or isinstance(type_permis,object):
try:
if type_permis.__convert__(obj) : return obj
--- /dev/null
+<ui version="4.0" >
+ <class>desMatrice</class>
+ <widget class="QDialog" name="desMatrice" >
+ <property name="geometry" >
+ <rect>
+ <x>0</x>
+ <y>0</y>
+ <width>400</width>
+ <height>300</height>
+ </rect>
+ </property>
+ <property name="windowTitle" >
+ <string>Dialog</string>
+ </property>
+ <layout class="QGridLayout" name="gridLayout" >
+ <item row="0" column="0" >
+ <widget class="QTableWidget" name="TBMatrice" />
+ </item>
+ <item row="1" column="0" >
+ <widget class="QDialogButtonBox" name="buttonBox" >
+ <property name="orientation" >
+ <enum>Qt::Horizontal</enum>
+ </property>
+ <property name="standardButtons" >
+ <set>QDialogButtonBox::Cancel|QDialogButtonBox::Ok</set>
+ </property>
+ </widget>
+ </item>
+ </layout>
+ </widget>
+ <resources/>
+ <connections>
+ <connection>
+ <sender>buttonBox</sender>
+ <signal>accepted()</signal>
+ <receiver>desMatrice</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>desMatrice</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>
desPlusieursBase.py desPlusieursInto.py desPoursuite.py desRacine.py desSelectVal.py \
desUniqueASSD.py desUniqueBase.py desUniqueComp.py desUniqueInto.py desUniqueSDCOInto.py \
desUniqueSDCO.py desVisu.py aideQT.py OptionsEditeur.py OptionsPdf.py myMain.py \
- desViewTexte.py desPixmap.py
+ desViewTexte.py desPixmap.py desMatrice.py
%.py:%.ui
${PYUIC} -x -o $@ $<
<property name="title" >
<string>&Aide</string>
</property>
+ <addaction name="actionEficas" />
+ <addaction name="actionVersion" />
</widget>
<widget class="QMenu" name="menuOptions" >
<property name="title" >
<string>TraduitV8V9</string>
</property>
</action>
+ <action name="actionEficas" >
+ <property name="text" >
+ <string>Eficas</string>
+ </property>
+ </action>
+ <action name="actionVersion" >
+ <property name="text" >
+ <string>Version</string>
+ </property>
+ </action>
</widget>
<resources/>
<connections/>
dict_reel_concept=construit_genea(epure2,self.appli.liste_simp_reel)
else:
dict_reel_concept={}
+ if nomConpet='sansnom' : nomConcept=''
if nomConcept !=None :
if len(dict_reel_concept) != 0:
self.appli.dict_reels[nomConcept]=dict_reel_concept
"""
self.appli=appli
try:
+ #if 1:
if not self.l_objets : self.analyse()
txt=''
for obj in self.l_objets:
txt = txt+str(obj)
+ #else :
except ParserException:
#Impossible de convertir le texte, on le retourne tel que
txt=self.texte
# ou la notation scientifique
s = str(valeur)
clefobj=etape.get_sdname()
- if self.appli and self.appli.dict_reels.has_key(clefobj):
- if self.appli.dict_reels[clefobj].has_key(valeur):
- s=self.appli.dict_reels[clefobj][valeur]
+ if self.appli.appliEficas and self.appli.appliEficas.dict_reels.has_key(clefobj):
+ if self.appli.appliEficas.dict_reels[clefobj].has_key(valeur):
+ s=self.appli.appliEficas.dict_reels[clefobj][valeur]
elif type(valeur) == types.StringType :
if valeur.find('\n') == -1:
# pas de retour chariot, on utilise repr
