Appli.py

Go to the documentation of this file.

# Copyright (C) 2006-2026  CEA, EDF
#
# 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, or (at your option) any later version.
#
# 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
#
 
"""
"""
import sys,os
from qt import *
from . import Tree
from . import PanelManager
from . import BoxManager
from . import Icons
from . import Items
from . import adapt
from . import Item
from . import logview
import pilot
import threading
import time
from . import CONNECTOR
from . import catalog
import traceback
import glob
 
class ErrorEvent(QCustomEvent):
  def __init__(self,caption,msg):
    QCustomEvent.__init__(self,8888)
    self.caption=caption
    self.msg=msg
  def process(self,parent):
    QMessageBox.warning(parent,self.caption,self.msg)
 
class Runner(threading.Thread):
  def __init__(self,parent,executor,proc):
    threading.Thread.__init__(self)
    self.parent=parent
    self.executor=executor
    self.proc=proc
 
  def run(self):
    try:
      self.executor.RunW(self.proc,0)
    except ValueError as ex:
      #traceback.print_exc()
      QApplication.postEvent(self.parent, ErrorEvent('YACS execution error',str(ex)))
 
class Browser(QVBox):
  def __init__(self,parent,proc):
    QVBox.__init__(self,parent)
    pp=Item.adapt(proc)
    self.proc=proc
    self.pproc=pp
    self.hSplitter = QSplitter(self,"hSplitter")
    self.objectBrowser=Tree.Tree(self.hSplitter,self.onSelect,self.onDblSelect)
    self.objectBrowser.additem(pp)
    self.panelManager=PanelManager.PanelManager(self.hSplitter)
    self.panelManager.setRootItem(pp)
    self.boxManager=BoxManager.BoxManager(self.hSplitter)
    self.boxManager.setRootItem(pp)
    self.selected=None
    self.executor=None
    self.resume=0
    self.thr=None
    self.log=logview.LogView()
 
  def view_log(self):
    self.log.text.setText(self.proc.getLogger("parser").getStr())
    self.log.show()
 
  def onDblSelect(self,item):
    #item is instance of Item.Item
    pass
 
  def onSelect(self,item):
    #item is instance of Item.Item
    self.selected=item
 
  def customEvent(self,ev):
    if ev.type() == 8888:
      ev.process(self)
 
  def run(self):
    if not self.executor:
      self.executor = pilot.ExecutorSwig()
    if self.thr and self.thr.isAlive():
      return
    #continue execution mode
    self.executor.setExecMode(0)
    #execute it in a thread
    self.thr = Runner(self, self.executor, self.proc)
    #as a daemon (no need to join)
    self.thr.setDaemon(1)
    #start the thread
    self.thr.start()
    time.sleep(0.1)
    self.resume=0
 
  def susp(self):
    """Suspend or resume an executing schema"""
    if not self.executor:
      return
    if not self.thr.isAlive():
      return
 
    if self.resume:
      #continue execution mode
      self.executor.setExecMode(0)
      #resume it
      self.executor.resumeCurrentBreakPoint()
      self.resume=0
    else:
      #step by step execution mode
      self.executor.setExecMode(1)
      self.resume=1
 
  def step(self):
    """Step on a paused schema"""
    if not self.executor:
      self.executor = pilot.ExecutorSwig()
    if not self.thr or not self.thr.isAlive():
      #start in step by step mode
      self.executor.setExecMode(1)
      self.thr = Runner(self, self.executor, self.proc)
      self.thr.setDaemon(1)
      self.thr.start()
      self.resume=1
      return
 
    #step by step execution mode
    self.resume=1
    self.executor.setExecMode(1)
    #resume it
    self.executor.resumeCurrentBreakPoint()
 
  def stop(self):
    """Stop the schema"""
    if not self.executor:
      return
    if not self.thr.isAlive():
      return
    self.executor.setExecMode(1)
    self.executor.waitPause()
    self.executor.resumeCurrentBreakPoint()
    #self.executor.stopExecution()
 
class Appli(QMainWindow):
  """
      Appli()
      Cree la fenetre principale de l'interface utilisateur
  """
  def __init__(self):
    QMainWindow.__init__(self)
    self.createWidgets()
    self.initActions()
    self.initMenus()
    self.initToolbar()
    self.initStatusbar()
    self.initYACS()
 
  def createWidgets(self):
    self.tabWidget = QTabWidget(self)
    self.currentPanel=None
    self.connect(self.tabWidget, SIGNAL('currentChanged(QWidget *)'),self.handlePanelChanged)
    self.setCentralWidget(self.tabWidget)
    self.resize(800,600)
 
  def handlePanelChanged(self,panel):
    self.currentPanel=panel
 
  def initActions(self):
    self.actions = []
 
    self.newAct=QAction('New', QIconSet(Icons.get_image("new")), '&New',
                          QKeySequence("CTRL+N"),self)
    self.newAct.setStatusTip('Open an empty editor window')
    self.newAct.setWhatsThis( """<b>New</b>"""
            """<p>An empty editor window will be created.</p>""")
    self.newAct.connect(self.newAct,SIGNAL('activated()'), self.newProc)
    self.actions.append(self.newAct)
 
    self.prefAct=QAction('Preferences',QIconSet(Icons.get_image("configure.png")),'&Preferences...',
                           0, self)
    self.prefAct.setStatusTip('Set the prefered configuration')
    self.prefAct.setWhatsThis("""<b>Preferences</b>"""
                              """<p>Set the configuration items of the application"""
                              """ with your prefered values.</p>""")
    self.prefAct.connect(self.prefAct,SIGNAL('activated()'), self.handlePreferences)
    self.actions.append(self.prefAct)
 
    self.runAct=QAction('Run',QIconSet(Icons.get_image("run.png")),'&Run',0,self)
    self.runAct.connect(self.runAct,SIGNAL('activated()'), self.run)
    self.runAct.setStatusTip('Run the selected schema')
    self.actions.append(self.runAct)
 
    self.suspAct=QAction('Suspend/resume',QIconSet(Icons.get_image("suspend-resume.gif")),'&Suspend/resume',0,self)
    self.suspAct.connect(self.suspAct,SIGNAL('activated()'), self.susp)
    self.suspAct.setStatusTip('Suspend/resume the selected schema')
    self.actions.append(self.suspAct)
 
    self.stepAct=QAction('Step',QIconSet(Icons.get_image("steps.png")),'&Step',0,self)
    self.stepAct.connect(self.stepAct,SIGNAL('activated()'), self.step)
    self.stepAct.setStatusTip('Step the selected schema')
    self.actions.append(self.stepAct)
 
    self.stopAct=QAction('Stop',QIconSet(Icons.get_image("kill.png")),'&Stop',0,self)
    self.stopAct.connect(self.stopAct,SIGNAL('activated()'), self.stop)
    self.stopAct.setStatusTip('Stop the selected schema')
    self.actions.append(self.stopAct)
 
    self.cataToolAct=QAction('Catalog Tool',0,self,"catatool")
    self.cataToolAct.connect(self.cataToolAct,SIGNAL('activated()'), self.cata_tool)
    self.actions.append(self.cataToolAct)
 
  def initMenus(self):
    menubar = self.menuBar()
 
    #menu file
    self.fileMenu=QPopupMenu(self)
    self.newAct.addTo(self.fileMenu)
    self.fileMenu.insertItem("&Open", self.openFile)
    self.fileMenu.insertItem("&Open Salome", self.openSalomeFile)
    self.loadersMenu = QPopupMenu(self)
    self.fileMenu.insertItem("Loaders", self.loadersMenu)
    self.loaders=[]
    for file in glob.glob("/local/chris/SALOME2/SUPERV/YACS/BR_CC/YACS_SRC/src/pyqt/*loader.py"):
      d,f=os.path.split(file)
      name=f[:-9]
      def call_loader(event,obj=self,file=file):
        obj.openFileWithLoader(file)
      self.loaders.append(call_loader)
      self.loadersMenu.insertItem(name, call_loader)
    menubar.insertItem('&File',self.fileMenu)
 
    #menu settings
    self.settingsMenu = QPopupMenu(self)
    menubar.insertItem('&Settings', self.settingsMenu)
    self.settingsMenu.insertTearOffHandle()
    self.prefAct.addTo(self.settingsMenu)
 
    #menu Edit
    self.editMenu = QPopupMenu(self)
    self.editMenu.insertItem("&Add node", self.addNode)
    menubar.insertItem('&Edit', self.editMenu)
 
    #menu Canvas
    #sous menu layout
    self.layoutMenu = QPopupMenu(self)
    self.layoutMenu.insertItem("&Left Right", self.LR)
    self.layoutMenu.insertItem("Right Left", self.RL)
    self.layoutMenu.insertItem("Top Bottom", self.TB)
    self.layoutMenu.insertItem("Bottom Top", self.BT)
    self.canvasMenu = QPopupMenu(self)
    self.canvasMenu.insertItem("&Zoom in", self.zoomIn)
    self.canvasMenu.insertItem("Zoom &out", self.zoomOut)
    self.canvasMenu.insertItem("Layout", self.layoutMenu)
    self.canvasMenu.insertItem("Ortholinks", self.orthoLinks)
    self.canvasMenu.insertItem("Clearlinks", self.clearLinks)
    self.canvasMenu.insertItem("&Update", self.updateCanvas)
    menubar.insertItem('&Canvas', self.canvasMenu)
 
    #menu window
    self.windowMenu = QPopupMenu(self)
    self.cataToolAct.addTo(self.windowMenu)
    self.windowMenu.insertItem("&Log", self.view_log)
    menubar.insertItem('&Window', self.windowMenu)
    self.connect(self.windowMenu, SIGNAL('aboutToShow()'), self.handleWindowMenu)
 
    #menu help
    self.help=QPopupMenu(self)
    menubar.insertItem('&Help',self.help)
    self.help.insertItem('&About',self.about,Qt.Key_F1)
    self.help.insertItem('About &Qt',self.aboutQt)
 
  def initYACS(self):
    import pilot
    import loader
    import salomeloader
    self.runtime= pilot.getRuntime()
    self.loader = loader.YACSLoader()
    self.executor = pilot.ExecutorSwig()
    self.salomeloader=salomeloader.SalomeLoader()
    self.loader.registerProcCataLoader()
 
  def openSalomeFile(self):
    fn = QFileDialog.getOpenFileName(QString.null,QString.null,self)
    if fn.isEmpty():
      self.statusBar().message('Loading aborted',2000)
      return
    fileName = str(fn)
    proc=self.salomeloader.load(fileName)
    logger=proc.getLogger("parser")
    if logger.hasErrors():
      self.logFile=logview.LogView()
      self.logFile.text.setText(logger.getStr())
      self.logFile.show()
 
    panel=Browser(self.tabWidget,proc)
    self.currentPanel=panel
    self.tabWidget.addTab( panel,os.path.basename(fileName))
    self.tabWidget.showPage(panel)
 
  def openFile(self):
    fn = QFileDialog.getOpenFileName(QString.null,QString.null,self)
    if fn.isEmpty():
      self.statusBar().message('Loading aborted',2000)
      return
    fileName = str(fn)
    proc=self.loader.load(fileName)
    logger=proc.getLogger("parser")
    if logger.hasErrors():
      self.logFile=logview.LogView()
      self.logFile.text.setText(logger.getStr())
      self.logFile.show()
 
    panel=Browser(self.tabWidget,proc)
    self.currentPanel=panel
    self.tabWidget.addTab( panel,os.path.basename(fileName))
    self.tabWidget.showPage(panel)
 
  def newProc(self):
    r=pilot.getRuntime()
    proc=r.createProc("pr")
    panel=Browser(self.tabWidget,proc)
    self.currentPanel=panel
    self.tabWidget.addTab( panel,proc.getName())
    self.tabWidget.showPage(panel)
 
  def openFileWithLoader(self,file):
    d,f=os.path.split(file)
    sys.path.insert(0,d)
    module=__import__(os.path.splitext(f)[0])
    del sys.path[0]
    loader=module.Loader()
 
    fn = QFileDialog.getOpenFileName(QString.null,QString.null,self)
    if fn.isEmpty():
      self.statusBar().message('Loading aborted',2000)
      return
    fileName = str(fn)
    proc=loader.load(fileName)
    logger=proc.getLogger("parser")
    if logger.hasErrors():
      self.logFile=logview.LogView()
      self.logFile.text.setText(logger.getStr())
      self.logFile.show()
 
    panel=Browser(self.tabWidget,proc)
    self.currentPanel=panel
    self.tabWidget.addTab( panel,os.path.basename(fileName))
    self.tabWidget.showPage(panel)
 
  def cata_tool(self):
    self.catalogTool=catalog.CatalogTool(self)
    self.catalogTool.show()
    return
 
  def view_log(self):
    if self.currentPanel:
      self.currentPanel.view_log()
 
  def LR(self,*args ):self.rankdir("LR")
  def RL(self,*args ):self.rankdir("RL")
  def TB(self,*args ):self.rankdir("TB")
  def BT(self,*args ):self.rankdir("BT")
 
  def rankdir(self,orient):
    if self.currentPanel and self.currentPanel.panelManager.visible:
      self.currentPanel.panelManager.visible.layout(orient)
 
  def updateCanvas(self):
    if self.currentPanel.selected:#item selected
      if isinstance(self.currentPanel.selected,Items.ItemComposedNode):
        #can update
        self.currentPanel.selected.graph.editor.updateCanvas()
 
  def addNode(self,node):
    if self.currentPanel and self.currentPanel.selected:#item selected
      if isinstance(self.currentPanel.selected,Items.ItemComposedNode):
        #can add node
        self.currentPanel.selected.addNode(node)
 
  def zoomIn(self):
    if self.currentPanel and self.currentPanel.panelManager.visible:
      if isinstance(self.currentPanel.panelManager.visible,Items.ItemComposedNode):
        #we can zoom
        self.currentPanel.panelManager.visible.graph.editor.zoomIn()
 
  def zoomOut(self):
    if self.currentPanel and self.currentPanel.panelManager.visible:
      if isinstance(self.currentPanel.panelManager.visible,Items.ItemComposedNode):
        #we can unzoom 
        self.currentPanel.panelManager.visible.graph.editor.zoomOut()
 
  def orthoLinks(self):
    if self.currentPanel and self.currentPanel.panelManager.visible:
      if isinstance(self.currentPanel.panelManager.visible,Items.ItemComposedNode):
        #it is a composed node with a graph
        self.currentPanel.panelManager.visible.graph.orthoLinks()
 
  def clearLinks(self):
    if self.currentPanel and self.currentPanel.panelManager.visible:
      if isinstance(self.currentPanel.panelManager.visible,Items.ItemComposedNode):
        #it is a composed node with a graph
        self.currentPanel.panelManager.visible.graph.clearLinks()
 
  def handlePreferences(self):
    pass
 
  def handleWindowMenu(self):
    pass
 
  def about(self):
    QMessageBox.about(self,'YACS browser GUI', 'YACS browser GUI')
 
  def aboutQt(self):
    QMessageBox.aboutQt(self,'YACS browser GUI')
 
  def run(self):
    if self.currentPanel:
      self.currentPanel.run()
 
  def susp(self):
    if self.currentPanel:
      self.currentPanel.susp()
 
  def step(self):
    if self.currentPanel:
      self.currentPanel.step()
 
  def stop(self):
    if self.currentPanel:
      self.currentPanel.stop()
 
  def initToolbar(self):
    tb = QToolBar(self)
    self.newAct.addTo(tb)
    self.runAct.addTo(tb)
    self.suspAct.addTo(tb)
    self.stepAct.addTo(tb)
    self.stopAct.addTo(tb)
    self.toolbars={}
    self.toolbars['File']=tb
 
  def initStatusbar(self):
    sb = self.statusBar()
    self.SBfile=QLabel(sb)
    sb.addWidget(self.SBfile)
    QWhatsThis.add(self.SBfile,
                   """<p>Partie de la statusbar qui donne le nom"""
                   """du fichier courant. </p>""")
    self.SBfile.setText("")
 
 
if __name__ == "__main__":
  from .Item import Item
  app = QApplication(sys.argv)
  t=Appli()
  t.objectBrowser.additem(Item("item1"))
  n=t.objectBrowser.additem(Item("item2"))
  n.additem(Item("item3"))
  app.setMainWidget(t)
  t.show()
  app.exec_loop()