Appli.py

Go to the documentation of this file.

# Copyright (C) 2006-2025  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.captioncaption=caption
    self.msgmsg=msg
  def process(self,parent):
    QMessageBox.warning(parent,self.captioncaption,self.msgmsg)
 
class Runner(threading.Thread):
  def __init__(self,parent,executor,proc):
    threading.Thread.__init__(self)
    self.parentparent=parent
    self.executorexecutor=executor
    self.procproc=proc
 
  def run(self):
    try:
      self.executorexecutor.RunW(self.procproc,0)
    except ValueError as ex:
      #traceback.print_exc()
      QApplication.postEvent(self.parentparent, ErrorEvent('YACS execution error',str(ex)))
 
class Browser(QVBox):
  def __init__(self,parent,proc):
    QVBox.__init__(self,parent)
    pp=Item.adapt(proc)
    self.procproc=proc
    self.pprocpproc=pp
    self.hSplitterhSplitter = QSplitter(self,"hSplitter")
    self.objectBrowserobjectBrowser=Tree.Tree(self.hSplitterhSplitter,self.onSelectonSelect,self.onDblSelectonDblSelect)
    self.objectBrowserobjectBrowser.additem(pp)
    self.panelManagerpanelManager=PanelManager.PanelManager(self.hSplitterhSplitter)
    self.panelManagerpanelManager.setRootItem(pp)
    self.boxManagerboxManager=BoxManager.BoxManager(self.hSplitterhSplitter)
    self.boxManagerboxManager.setRootItem(pp)
    self.selectedselected=None
    self.executorexecutor=None
    self.resumeresume=0
    self.thrthr=None
    self.loglog=logview.LogView()
 
  def view_log(self):
    self.loglog.text.setText(self.procproc.getLogger("parser").getStr())
    self.loglog.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.executorexecutor:
      self.executorexecutor = pilot.ExecutorSwig()
    if self.thrthr and self.thrthr.isAlive():
      return
    #continue execution mode
    self.executorexecutor.setExecMode(0)
    #execute it in a thread
    self.thrthr = Runner(self, self.executorexecutor, self.procproc)
    #as a daemon (no need to join)
    self.thrthr.setDaemon(1)
    #start the thread
    self.thrthr.start()
    time.sleep(0.1)
    self.resumeresume=0
 
  def susp(self):
    """Suspend or resume an executing schema"""
    if not self.executorexecutor:
      return
    if not self.thrthr.isAlive():
      return
 
    if self.resumeresume:
      #continue execution mode
      self.executorexecutor.setExecMode(0)
      #resume it
      self.executorexecutor.resumeCurrentBreakPoint()
      self.resumeresume=0
    else:
      #step by step execution mode
      self.executorexecutor.setExecMode(1)
      self.resumeresume=1
 
  def step(self):
    """Step on a paused schema"""
    if not self.executorexecutor:
      self.executorexecutor = pilot.ExecutorSwig()
    if not self.thrthr or not self.thrthr.isAlive():
      #start in step by step mode
      self.executorexecutor.setExecMode(1)
      self.thrthr = Runner(self, self.executorexecutor, self.procproc)
      self.thrthr.setDaemon(1)
      self.thrthr.start()
      self.resumeresume=1
      return
 
    #step by step execution mode
    self.resumeresume=1
    self.executorexecutor.setExecMode(1)
    #resume it
    self.executorexecutor.resumeCurrentBreakPoint()
 
  def stop(self):
    """Stop the schema"""
    if not self.executorexecutor:
      return
    if not self.thrthr.isAlive():
      return
    self.executorexecutor.setExecMode(1)
    self.executorexecutor.waitPause()
    self.executorexecutor.resumeCurrentBreakPoint()
    #self.executor.stopExecution()
 
class Appli(QMainWindow):
  """
      Appli()
      Cree la fenetre principale de l'interface utilisateur
  """
  def __init__(self):
    QMainWindow.__init__(self)
    self.createWidgetscreateWidgets()
    self.initActionsinitActions()
    self.initMenusinitMenus()
    self.initToolbarinitToolbar()
    self.initStatusbarinitStatusbar()
    self.initYACSinitYACS()
 
  def createWidgets(self):
    self.tabWidgettabWidget = QTabWidget(self)
    self.currentPanelcurrentPanel=None
    self.connect(self.tabWidgettabWidget, SIGNAL('currentChanged(QWidget *)'),self.handlePanelChangedhandlePanelChanged)
    self.setCentralWidget(self.tabWidgettabWidget)
    self.resize(800,600)
 
  def handlePanelChanged(self,panel):
    self.currentPanelcurrentPanel=panel
 
  def initActions(self):
    self.actionsactions = []
 
    self.newActnewAct=QAction('New', QIconSet(Icons.get_image("new")), '&New',
                          QKeySequence("CTRL+N"),self)
    self.newActnewAct.setStatusTip('Open an empty editor window')
    self.newActnewAct.setWhatsThis( """<b>New</b>"""
            """<p>An empty editor window will be created.</p>""")
    self.newActnewAct.connect(self.newActnewAct,SIGNAL('activated()'), self.newProcnewProc)
    self.actionsactions.append(self.newActnewAct)
 
    self.prefActprefAct=QAction('Preferences',QIconSet(Icons.get_image("configure.png")),'&Preferences...',
                           0, self)
    self.prefActprefAct.setStatusTip('Set the prefered configuration')
    self.prefActprefAct.setWhatsThis("""<b>Preferences</b>"""
                              """<p>Set the configuration items of the application"""
                              """ with your prefered values.</p>""")
    self.prefActprefAct.connect(self.prefActprefAct,SIGNAL('activated()'), self.handlePreferenceshandlePreferences)
    self.actionsactions.append(self.prefActprefAct)
 
    self.runActrunAct=QAction('Run',QIconSet(Icons.get_image("run.png")),'&Run',0,self)
    self.runActrunAct.connect(self.runActrunAct,SIGNAL('activated()'), self.runrun)
    self.runActrunAct.setStatusTip('Run the selected schema')
    self.actionsactions.append(self.runActrunAct)
 
    self.suspActsuspAct=QAction('Suspend/resume',QIconSet(Icons.get_image("suspend-resume.gif")),'&Suspend/resume',0,self)
    self.suspActsuspAct.connect(self.suspActsuspAct,SIGNAL('activated()'), self.suspsusp)
    self.suspActsuspAct.setStatusTip('Suspend/resume the selected schema')
    self.actionsactions.append(self.suspActsuspAct)
 
    self.stepActstepAct=QAction('Step',QIconSet(Icons.get_image("steps.png")),'&Step',0,self)
    self.stepActstepAct.connect(self.stepActstepAct,SIGNAL('activated()'), self.stepstep)
    self.stepActstepAct.setStatusTip('Step the selected schema')
    self.actionsactions.append(self.stepActstepAct)
 
    self.stopActstopAct=QAction('Stop',QIconSet(Icons.get_image("kill.png")),'&Stop',0,self)
    self.stopActstopAct.connect(self.stopActstopAct,SIGNAL('activated()'), self.stopstop)
    self.stopActstopAct.setStatusTip('Stop the selected schema')
    self.actionsactions.append(self.stopActstopAct)
 
    self.cataToolActcataToolAct=QAction('Catalog Tool',0,self,"catatool")
    self.cataToolActcataToolAct.connect(self.cataToolActcataToolAct,SIGNAL('activated()'), self.cata_toolcata_tool)
    self.actionsactions.append(self.cataToolActcataToolAct)
 
  def initMenus(self):
    menubar = self.menuBar()
 
    #menu file
    self.fileMenufileMenu=QPopupMenu(self)
    self.newActnewAct.addTo(self.fileMenufileMenu)
    self.fileMenufileMenu.insertItem("&Open", self.openFileopenFile)
    self.fileMenufileMenu.insertItem("&Open Salome", self.openSalomeFileopenSalomeFile)
    self.loadersMenuloadersMenu = QPopupMenu(self)
    self.fileMenufileMenu.insertItem("Loaders", self.loadersMenuloadersMenu)
    self.loadersloaders=[]
    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.loadersloaders.append(call_loader)
      self.loadersMenuloadersMenu.insertItem(name, call_loader)
    menubar.insertItem('&File',self.fileMenufileMenu)
 
    #menu settings
    self.settingsMenusettingsMenu = QPopupMenu(self)
    menubar.insertItem('&Settings', self.settingsMenusettingsMenu)
    self.settingsMenusettingsMenu.insertTearOffHandle()
    self.prefActprefAct.addTo(self.settingsMenusettingsMenu)
 
    #menu Edit
    self.editMenueditMenu = QPopupMenu(self)
    self.editMenueditMenu.insertItem("&Add node", self.addNodeaddNode)
    menubar.insertItem('&Edit', self.editMenueditMenu)
 
    #menu Canvas
    #sous menu layout
    self.layoutMenulayoutMenu = QPopupMenu(self)
    self.layoutMenulayoutMenu.insertItem("&Left Right", self.LRLR)
    self.layoutMenulayoutMenu.insertItem("Right Left", self.RLRL)
    self.layoutMenulayoutMenu.insertItem("Top Bottom", self.TBTB)
    self.layoutMenulayoutMenu.insertItem("Bottom Top", self.BTBT)
    self.canvasMenucanvasMenu = QPopupMenu(self)
    self.canvasMenucanvasMenu.insertItem("&Zoom in", self.zoomInzoomIn)
    self.canvasMenucanvasMenu.insertItem("Zoom &out", self.zoomOutzoomOut)
    self.canvasMenucanvasMenu.insertItem("Layout", self.layoutMenulayoutMenu)
    self.canvasMenucanvasMenu.insertItem("Ortholinks", self.orthoLinksorthoLinks)
    self.canvasMenucanvasMenu.insertItem("Clearlinks", self.clearLinksclearLinks)
    self.canvasMenucanvasMenu.insertItem("&Update", self.updateCanvasupdateCanvas)
    menubar.insertItem('&Canvas', self.canvasMenucanvasMenu)
 
    #menu window
    self.windowMenuwindowMenu = QPopupMenu(self)
    self.cataToolActcataToolAct.addTo(self.windowMenuwindowMenu)
    self.windowMenuwindowMenu.insertItem("&Log", self.view_logview_log)
    menubar.insertItem('&Window', self.windowMenuwindowMenu)
    self.connect(self.windowMenuwindowMenu, SIGNAL('aboutToShow()'), self.handleWindowMenuhandleWindowMenu)
 
    #menu help
    self.helphelp=QPopupMenu(self)
    menubar.insertItem('&Help',self.helphelp)
    self.helphelp.insertItem('&About',self.aboutabout,Qt.Key_F1)
    self.helphelp.insertItem('About &Qt',self.aboutQtaboutQt)
 
  def initYACS(self):
    import pilot
    import loader
    import salomeloader
    self.runtimeruntime= pilot.getRuntime()
    self.loaderloader = loader.YACSLoader()
    self.executorexecutor = pilot.ExecutorSwig()
    self.salomeloadersalomeloader=salomeloader.SalomeLoader()
    self.loaderloader.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.salomeloadersalomeloader.load(fileName)
    logger=proc.getLogger("parser")
    if logger.hasErrors():
      self.logFilelogFile=logview.LogView()
      self.logFilelogFile.text.setText(logger.getStr())
      self.logFilelogFile.show()
 
    panel=Browser(self.tabWidgettabWidget,proc)
    self.currentPanelcurrentPanel=panel
    self.tabWidgettabWidget.addTab( panel,os.path.basename(fileName))
    self.tabWidgettabWidget.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.loaderloader.load(fileName)
    logger=proc.getLogger("parser")
    if logger.hasErrors():
      self.logFilelogFile=logview.LogView()
      self.logFilelogFile.text.setText(logger.getStr())
      self.logFilelogFile.show()
 
    panel=Browser(self.tabWidgettabWidget,proc)
    self.currentPanelcurrentPanel=panel
    self.tabWidgettabWidget.addTab( panel,os.path.basename(fileName))
    self.tabWidgettabWidget.showPage(panel)
 
  def newProc(self):
    r=pilot.getRuntime()
    proc=r.createProc("pr")
    panel=Browser(self.tabWidgettabWidget,proc)
    self.currentPanelcurrentPanel=panel
    self.tabWidgettabWidget.addTab( panel,proc.getName())
    self.tabWidgettabWidget.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.logFilelogFile=logview.LogView()
      self.logFilelogFile.text.setText(logger.getStr())
      self.logFilelogFile.show()
 
    panel=Browser(self.tabWidgettabWidget,proc)
    self.currentPanelcurrentPanel=panel
    self.tabWidgettabWidget.addTab( panel,os.path.basename(fileName))
    self.tabWidgettabWidget.showPage(panel)
 
  def cata_tool(self):
    self.catalogToolcatalogTool=catalog.CatalogTool(self)
    self.catalogToolcatalogTool.show()
    return
 
  def view_log(self):
    if self.currentPanelcurrentPanel:
      self.currentPanelcurrentPanel.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.currentPanelcurrentPanel and self.currentPanelcurrentPanel.panelManager.visible:
      self.currentPanelcurrentPanel.panelManager.visible.layout(orient)
 
  def updateCanvas(self):
    if self.currentPanelcurrentPanel.selected:#item selected
      if isinstance(self.currentPanelcurrentPanel.selected,Items.ItemComposedNode):
        #can update
        self.currentPanelcurrentPanel.selected.graph.editor.updateCanvas()
 
  def addNode(self,node):
    if self.currentPanelcurrentPanel and self.currentPanelcurrentPanel.selected:#item selected
      if isinstance(self.currentPanelcurrentPanel.selected,Items.ItemComposedNode):
        #can add node
        self.currentPanelcurrentPanel.selected.addNode(node)
 
  def zoomIn(self):
    if self.currentPanelcurrentPanel and self.currentPanelcurrentPanel.panelManager.visible:
      if isinstance(self.currentPanelcurrentPanel.panelManager.visible,Items.ItemComposedNode):
        #we can zoom
        self.currentPanelcurrentPanel.panelManager.visible.graph.editor.zoomIn()
 
  def zoomOut(self):
    if self.currentPanelcurrentPanel and self.currentPanelcurrentPanel.panelManager.visible:
      if isinstance(self.currentPanelcurrentPanel.panelManager.visible,Items.ItemComposedNode):
        #we can unzoom 
        self.currentPanelcurrentPanel.panelManager.visible.graph.editor.zoomOut()
 
  def orthoLinks(self):
    if self.currentPanelcurrentPanel and self.currentPanelcurrentPanel.panelManager.visible:
      if isinstance(self.currentPanelcurrentPanel.panelManager.visible,Items.ItemComposedNode):
        #it is a composed node with a graph
        self.currentPanelcurrentPanel.panelManager.visible.graph.orthoLinks()
 
  def clearLinks(self):
    if self.currentPanelcurrentPanel and self.currentPanelcurrentPanel.panelManager.visible:
      if isinstance(self.currentPanelcurrentPanel.panelManager.visible,Items.ItemComposedNode):
        #it is a composed node with a graph
        self.currentPanelcurrentPanel.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.currentPanelcurrentPanel:
      self.currentPanelcurrentPanel.run()
 
  def susp(self):
    if self.currentPanelcurrentPanel:
      self.currentPanelcurrentPanel.susp()
 
  def step(self):
    if self.currentPanelcurrentPanel:
      self.currentPanelcurrentPanel.step()
 
  def stop(self):
    if self.currentPanelcurrentPanel:
      self.currentPanelcurrentPanel.stop()
 
  def initToolbar(self):
    tb = QToolBar(self)
    self.newActnewAct.addTo(tb)
    self.runActrunAct.addTo(tb)
    self.suspActsuspAct.addTo(tb)
    self.stepActstepAct.addTo(tb)
    self.stopActstopAct.addTo(tb)
    self.toolbarstoolbars={}
    self.toolbarstoolbars['File']=tb
 
  def initStatusbar(self):
    sb = self.statusBar()
    self.SBfileSBfile=QLabel(sb)
    sb.addWidget(self.SBfileSBfile)
    QWhatsThis.add(self.SBfileSBfile,
                   """<p>Partie de la statusbar qui donne le nom"""
                   """du fichier courant. </p>""")
    self.SBfileSBfile.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()