Editeur/appli.py

   1 # -*- coding: utf-8 -*-
   2 #            CONFIGURATION MANAGEMENT OF EDF VERSION
   3 # ======================================================================
   4 # COPYRIGHT (C) 1991 - 2002  EDF R&D                  WWW.CODE-ASTER.ORG
   5 # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
   6 # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
   7 # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
   8 # (AT YOUR OPTION) ANY LATER VERSION.
   9 #
  10 # THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
  11 # WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
  12 # MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
  13 # GENERAL PUBLIC LICENSE FOR MORE DETAILS.
  14 #
  15 # YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
  16 # ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
  17 #    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
  18 #
  19 #
  20 # ======================================================================
  21 """
  22     Ce module contient la classe APPLI qui est la classe mère de
  23     l'application EFICAS. Elle prend en charge l'organisation générale
  24     des composants graphiques et l'initialisation Tk
  25     L'aspect applicatif doit etre pris en charge par la classe dérivée
  26 """
  27 # Modules Python
  28 import os
  29 import string
  30 import sys
  31 import types
  32 import Pmw
  33 import Tkinter
  34 from widgets import showerror
  35
  36 # Modules Eficas
  37 import splash
  38 import prefs
  39 import styles
  40 from styles import style
  41 import fontes
  42 import tooltip
  43 import properties
  44 import convert,generator
  45 import comploader
  46 from utils import extension_fichier,stripPath
  47
  48 from widgets import Fenetre
  49 from Misc import MakeNomComplet
  50 import session
  51 import listeFichiers
  52 import listePatrons
  53
  54 VERSION="EFICAS v1.12"
  55
  56 class APPLI:
  57   def __init__ (self,master,code=prefs.code,fichier=None,test=0) :
  58       self.code=code
  59       self.top=master
  60       self.top.protocol("WM_DELETE_WINDOW",self.exitEFICAS)
  61
  62       #dimensionnement de la fenetre principale
  63       #aspect ratio de l'ecran
  64       aspect=float(self.top.winfo_screenwidth())/float(self.top.winfo_screenheight())
  65       #resolution (pixels par point). On utilise le fait qu'on a "normalement" 72 points par inch
  66       resolution= self.top.winfo_screenwidth()/(self.top.winfo_screenmmwidth()/25.4*72)
  67       DDY=max(20,resolution*(fontes.standard[1]+4)) #largeur d'un caractere fonte standard en pixel
  68       x=int(45*DDY) #largeur d'ouverture de 45 caracteres de fonte standard
  69       y=int(25*DDY) #hauteur d'ouverture de 25 caracteres de fonte standard
  70       minx=x*8/10 #largeur min (80 pour cent de largeur)
  71       miny=y*8/10 #hauteur min (80 pour cent de hauteur)
  72       self.top.minsize(minx,miny)
  73       self.top.geometry('%dx%d' % (x,y))
  74
  75       self.top.title(VERSION + ' pour '+self.code)
  76       self.titre=VERSION + ' pour '+self.code
  77       self.top.withdraw()
  78       self.initializeTk(master)
  79       Pmw.initialise(master)
  80
  81       self.dict_reels={}
  82       self.liste_simp_reel=[]
  83       # L'attribut test permet d'activer les panneaux de splash et d'erreur (test=0)
  84       # Si test est different de 0, les panneaux ne sont pas activés
  85       self.test=test
  86
  87       # Lecture des parametres de configuration (fichier global editeur.ini
  88       # et utilisateur eficas.ini)
  89       self.lecture_parametres()
  90
  91       self.format_fichier = Tkinter.StringVar()
  92       self.message=''
  93       # Avant la creation du bureau qui lit le catalogue
  94       self.version_code=session.d_env.cata
  95
  96       # Creation de la menubar, toolbar, messagebar
  97       self.cree_composants_graphiques()
  98       # Creation des autres composants graphiques dont le bureau (parametrable par prefs.py)
  99       self.load_appli_composants()
 100       self.listeFichiers=listeFichiers.listeFichiers(self)
 101       self.listePatrons=listePatrons.listePatrons(self)
 102       self.dir=None
 103
 104       # Fermer le splash et deiconifier la fenetre principale si on n'est pas en test
 105       if (self.test == 0):
 106            splash.fini_splash()
 107            #self.affiche_FAQ()
 108
 109       # Ouverture des fichiers de commandes donnes sur la ligne de commande
 110       cwd=os.getcwd()
 111       self.dir=cwd
 112       for study in session.d_env.studies:
 113           os.chdir(cwd)
 114           d=session.get_unit(study,self)
 115           self.bureau.openJDC(file=study["comm"],units=d)
 116
 117
 118   def send_message(self,message):
 119       self.message=message
 120
 121   def exitEFICAS(self):
 122       self.quit()
 123
 124   def quit(self):
 125       self.top.quit()
 126
 127   def lecture_parametres(self):
 128       """
 129           Active la lecture des paramètres standards et utilisateur
 130       """
 131       if (self.test == 0):
 132          splash._splash.configure(text = "Chargement des paramètres utilisateur")
 133       import configuration
 134       self.CONFIGURATION = configuration.make_config(self,prefs.REPINI)
 135       self.CONFIGStyle = configuration.make_config_style(self,prefs.REPINI)
 136
 137   def cree_composants_graphiques(self):
 138       """
 139           Cree les constituants graphiques fixes de l'application :
 140            - menubar
 141            - toolbar
 142            - statusbar
 143       """
 144       if (self.test == 0):
 145          splash._splash.configure(text = "Chargement de l'IHM")
 146          splash._splash.configure(text = "Chargement de la menubar")
 147       import menubar
 148       self.menubar=menubar.MENUBAR(self,self.top)
 149       if (self.test == 0):
 150          splash._splash.configure(text = "Chargement de la toolbar")
 151       import toolbar
 152       self.toolbar=toolbar.TOOLBAR(self,self.top)
 153       if (self.test == 0):
 154          splash._splash.configure(text = "Chargement de la statusbar")
 155       import statusbar
 156       self.statusbar=statusbar.STATUSBAR(self.top,styles.style.statusfont)
 157
 158   def load_appli_composants(self):
 159       """
 160           Cree les autres constituants graphiques de l'application :
 161            - bureau
 162            - readercata
 163            - ...
 164           Cette creation est parametrable par fichier prefs.py
 165       """
 166       if (self.test == 0):
 167          splash._splash.configure(text = "Chargement des appli_composants")
 168       for mname in self.appli_composants:
 169          self.load_appli_composant(mname)
 170
 171   def load_appli_composant(self,mname):
 172       module=__import__(mname,globals(),locals())
 173       factory=getattr(module,mname.upper())
 174       appli_composant=factory(self,self.top)
 175       setattr(self,mname,appli_composant)
 176       self.fill_menus(appli_composant,appli_composant.menu_defs)
 177       self.toolbar.creer_boutons_appli_composant(appli_composant.button_defs,appli_composant)
 178
 179   def affiche_FAQ(self):
 180       import faq
 181       faq.affiche(self.top)
 182
 183   def affiche_infos(self,message):
 184       self.statusbar.affiche_infos(message)
 185       return
 186
 187   def  initializeTk(self, root):
 188         """
 189         Initialize platform specific options
 190         """
 191         if sys.platform == 'mac':
 192             self.initializeTk_mac(root)
 193         elif sys.platform == 'win32':
 194             self.initializeTk_win32(root)
 195         else:
 196             self.initializeTk_unix(root)
 197
 198   def initializeTk_win32(self, root):
 199         root.option_add('*Font', fontes.standard)
 200         root.option_add('*EntryField.Entry.Font', fontes.standard)
 201         root.option_add('*Listbox*Font',fontes.standard)
 202
 203   def initializeTk_colors_common(self, root):
 204         root.option_add('*background', style.background)
 205         root.option_add('*foreground', style.foreground)
 206         root.option_add('*EntryField.Entry.background', style.entry_background)
 207         root.option_add('*Entry*background', style.entry_background)
 208         root.option_add('*Listbox*background', style.list_background)
 209         root.option_add('*Listbox*selectBackground', style.list_select_background)
 210         root.option_add('*Listbox*selectForeground', style.list_select_foreground)
 211
 212   def initializeTk_mac(self, root):
 213         self.initializeTk_colors_common(root)
 214
 215   def initializeTk_unix(self, root):
 216       root.option_add('*Font', fontes.standard)
 217       root.option_add('*EntryField.Entry.Font',fontes.standard )
 218       root.option_add('*Listbox*Font', fontes.standard)
 219       self.initializeTk_colors_common(root)
 220
 221   def get_texte_infos(self):
 222       """
 223           Retourne un texte d'informations sur la session courante d'EFICAS
 224       """
 225       texte = VERSION + '\n\n'
 226       texte = texte + 'EFICAS est un produit développé par \nEDF-R&D\n'
 227       texte = texte + 'Equipe : SINETICS\n\n'
 228       texte = texte + 'Code utilisé : %s version %s\n' % (self.code,properties.version)
 229       return texte
 230
 231   def efface_aide(self,event):
 232       """
 233           Efface la bulle d'aide d'un panneau
 234       """
 235       try:
 236           self.aide.destroy()
 237       except:
 238           pass
 239       return
 240
 241   def affiche_aide(self,event,aide):
 242       """
 243           Affiche l'aide concernant un panneau
 244       """
 245       x=event.x
 246       y=event.y
 247       widget=event.widget
 248       self.aide=tooltip.TOOLTIP(widget)
 249       self.aide.xoffset = 10
 250       self.aide.yoffset = - widget.winfo_height()/2
 251       self.aide.setText(aide)
 252       self.aide._showTip()
 253       return
 254
 255   def cree_menu(self,menu,itemlist,appli_composant):
 256       """
 257           Ajoute les items du tuple itemlist
 258           dans le menu menu
 259       """
 260       number_item=0
 261       radio=None
 262       for item in itemlist:
 263          number_item=number_item + 1
 264          raccourci_label=""
 265          if not item :
 266             #menu.add_separator()
 267             pass
 268          else:
 269             if len(item)==3:
 270                raccourci=item[2]
 271                raccourci_label="   "+raccourci
 272                newitem=(item[0],item[1])
 273             else :
 274                if len(item)==4:
 275                   raccourci=item[2]
 276                   raccourci_label="   "+item[3]
 277                   newitem=(item[0],item[1])
 278                else :
 279                   raccourci=""
 280                   newitem=item
 281             item=newitem
 282             label,method=item
 283             if type(method) == types.TupleType:
 284                # On a un tuple => on cree une cascade
 285                menu_cascade=Tkinter.Menu(menu)
 286                menu.add_cascade(label=label,menu=menu_cascade)
 287                self.cree_menu(menu_cascade,method,appli_composant)
 288             elif method[0] == '&':
 289                # On a une chaine avec & en tete => on cree un radiobouton
 290                command=getattr(appli_composant,method[1:])
 291                menu.add_radiobutton(label=label,command=command)
 292                if radio == None:radio=number_item
 293             else:
 294                command=getattr(appli_composant,method)
 295                menu.add_command(label=label,accelerator=raccourci_label,command=command)
 296                if raccourci != "" :
 297                   self.top.bind(raccourci,command)
 298       # Si au moins un radiobouton existe on invoke le premier
 299       if radio:menu.invoke(radio)
 300
 301   def fill_menus(self,appli_composant,defs):
 302       menudict=self.menubar.menudict
 303       for mname,itemlist in defs:
 304           menu=menudict.get(mname)
 305           if not menu:continue
 306           self.cree_menu(menu,itemlist,appli_composant)
 307
 308   def update_jdc_courant(self):
 309       self.bureau.update_jdc_courant()
 310
 311   def affiche_alerte(self,titre,message):
 312       f=Fenetre(self, titre="Compte-rendu d'erreur", texte = titre + "\n\n" + message)
 313       f.wait()
 314
 315
 316 class valeur:
 317    def __init__(self,v=None):
 318       self.v=v
 319    def set(self,v):
 320       self.v=v
 321    def get(self):
 322       return self.v
 323
 324 class STANDALONE(APPLI):
 325    def __init__ (self,code=prefs.code,fichier=None,version='v8.2') :
 326       self.code=code
 327       self.top=None
 328       self.format_fichier=valeur()
 329
 330       self.dict_reels={}
 331       self.liste_simp_reel=[]
 332       # L'attribut test doit valoir 1 si on ne veut pas creer les fenetres
 333       self.test=1
 334       self.titre="STANDALONE POUR TEST"
 335
 336       # Lecture des parametres de configuration (fichier global editeur.ini
 337       # et utilisateur eficas.ini)
 338       self.lecture_parametres()
 339
 340       self.message=''
 341       # Avant la creation du bureau qui lit le catalogue
 342       self.version_code=version
 343       import readercata
 344       self.readercata=readercata.READERCATA(self,None)
 345
 346       self.dir=None
 347
 348    def affiche_infos(self,message):
 349       return
 350
 351    def get_text_JDC(self,JDC,format):
 352       if generator.plugins.has_key(format):
 353          # Le generateur existe on l'utilise
 354          g=generator.plugins[format]()
 355          jdc_formate=g.gener(JDC,format='beautifie')
 356          return jdc_formate
 357       else:
 358          # Il n'existe pas c'est une erreur
 359          return
 360
 361    def newJDC(self):
 362       CONTEXT.unset_current_step()
 363       J=self.readercata.cata[0].JdC(procedure="",
 364                                     appli=self,
 365                                     cata=self.readercata.cata,
 366                                     cata_ord_dico=self.readercata.cata_ordonne_dico,
 367                                     rep_mat=self.CONFIGURATION.rep_mat,
 368                                    )
 369       J.analyse()
 370       return J
 371
 372    def openJDC(self,file):
 373       self.fileName = file
 374       e=extension_fichier(file)
 375       self.JDCName=stripPath(file)
 376       self.initialdir = os.path.dirname(os.path.abspath(file))
 377       format=self.format_fichier.get()
 378       # Il faut convertir le contenu du fichier en fonction du format
 379       if convert.plugins.has_key(format):
 380          # Le convertisseur existe on l'utilise
 381          p=convert.plugins[format]()
 382          p.readfile(file)
 383          text=p.convert('exec',self)
 384          if not p.cr.estvide():
 385              raise ValueError(str(p.cr))
 386
 387       # On se met dans le repertoire ou se trouve le fichier de commandes
 388       # pour trouver les eventuels fichiers include ou autres
 389       # localises a cote du fichier de commandes
 390       os.chdir(self.initialdir)
 391       CONTEXT.unset_current_step()
 392       J=self.readercata.cata[0].JdC(procedure=text,
 393                                     appli=self,
 394                                     cata=self.readercata.cata,
 395                                     cata_ord_dico=self.readercata.cata_ordonne_dico,
 396                                     nom=self.JDCName,
 397                                     rep_mat=self.CONFIGURATION.rep_mat,
 398                                    )
 399       J.analyse()
 400       txt= J.cr.get_mess_exception()
 401       if txt:raise ValueError(txt)
 402       return J
 403
 404    def openTXT(self,text):
 405       self.JDCName="TEXT"
 406       CONTEXT.unset_current_step()
 407       J=self.readercata.cata[0].JdC(procedure=text,
 408                                     appli=self,
 409                                     cata=self.readercata.cata,
 410                                     cata_ord_dico=self.readercata.cata_ordonne_dico,
 411                                     nom=self.JDCName,
 412                                     rep_mat=self.CONFIGURATION.rep_mat,
 413                                    )
 414       J.analyse()
 415       txt= J.cr.get_mess_exception()
 416       if txt:raise ValueError(txt)
 417       return J
 418
 419    def create_item(self,obj):
 420       return comploader.make_objecttreeitem(self,getattr(obj,"nom","item"),obj)
 421
 422    def get_file(self,unite=None,fic_origine = ''):
 423       """
 424           Retourne le nom du fichier correspondant a l unite logique unite (entier)
 425           ou d'un fichier poursuite
 426       """
 427       f,ext=os.path.splitext(fic_origine)
 428       if unite :
 429           #include
 430           finclude=f+".%d" % unite
 431       else:
 432           #poursuite
 433           n=ext[-1]
 434           if n == '0':
 435              ext=".comm"
 436           else:
 437              ext=".com%d" % (string.atoi(n)-1)
 438              if ext == '.com0' and not os.path.isfile(f+".com0"):
 439                 ext=".comm"
 440           finclude=f+ext
 441       ff=open(finclude)
 442       text=ff.read()
 443       ff.close()
 444       return finclude,text
 445
 446    def affiche_alerte(self,titre,message):
 447       print titre+ "\n\n" + message