src/SalomeApp/pluginsdemo/salome_plugins.py

   1 # -*- coding: iso-8859-1 -*-
   2 # Copyright (C) 2010-2016  CEA/DEN, EDF R&D, OPEN CASCADE
   3 #
   4 # This library is free software; you can redistribute it and/or
   5 # modify it under the terms of the GNU Lesser General Public
   6 # License as published by the Free Software Foundation; either
   7 # version 2.1 of the License, or (at your option) any later version.
   8 #
   9 # This library is distributed in the hope that it will be useful,
  10 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12 # Lesser General Public License for more details.
  13 #
  14 # You should have received a copy of the GNU Lesser General Public
  15 # License along with this library; if not, write to the Free Software
  16 # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  17 #
  18 # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  19 #
  20 # Author : Guillaume Boulant (EDF)
  21
  22 import salome_pluginsmanager
  23
  24 DEMO_IS_ACTIVATED = False
  25
  26 if DEMO_IS_ACTIVATED:
  27   # Check that GEOM and SMESH modules are present
  28   try:
  29     import GEOM
  30     from salome.geom import geomBuilder
  31     geompy = geomBuilder.New(salome.myStudy)
  32
  33     import SMESH, SALOMEDS
  34     from salome.smesh import smeshBuilder
  35     smesh =  smeshBuilder.New(salome.myStudy)
  36   except:
  37     DEMO_IS_ACTIVATED = False
  38
  39 if DEMO_IS_ACTIVATED:
  40   # -------------------------------------------------------------------------
  41   # Example 1: creation of basic objects.
  42   # The plugin function is implemented here and declared in the pluginsmanager.
  43   #
  44   import salome
  45
  46   def trihedron(context):
  47       import GEOM
  48       from salome.geom import geomBuilder
  49
  50       # Intialize the geompy factory with the active study
  51       activeStudy = context.study
  52       geompy = geomBuilder.New(activeStudy)
  53
  54       # Create the objects
  55       Vx = geompy.MakeVectorDXDYDZ(10, 0, 0)
  56       Vy = geompy.MakeVectorDXDYDZ(0, 10, 0)
  57       Vz = geompy.MakeVectorDXDYDZ(0, 0, 10)
  58       origin = geompy.MakeVertex(0, 0, 0)
  59
  60       # Register the objects in the active study
  61       geompy.addToStudy( Vx, "Vx" )
  62       geompy.addToStudy( Vy, "Vy" )
  63       geompy.addToStudy( Vz, "Vz" )
  64       geompy.addToStudy( origin, "origin" )
  65
  66
  67   salome_pluginsmanager.AddFunction('DEMO/O,Vx,Vy,Vz',
  68                                     'Creates the trihedron',
  69                                     trihedron)
  70
  71
  72   # -------------------------------------------------------------------------
  73   # Example 1 bis: creation of basic objects and automatic display
  74   def trihedron_withdisplay(context):
  75       import GEOM
  76       from salome.geom import geomBuilder
  77
  78       # Intialize the geompy factory with the active study
  79       activeStudy = context.study
  80       geompy = geomBuilder.New(activeStudy)
  81
  82       # Create the objects
  83       Vx = geompy.MakeVectorDXDYDZ(10, 0, 0)
  84       Vy = geompy.MakeVectorDXDYDZ(0, 10, 0)
  85       Vz = geompy.MakeVectorDXDYDZ(0, 0, 10)
  86       origin = geompy.MakeVertex(0, 0, 0)
  87
  88       # Register the objects in the active study
  89       entries=[]
  90       entries.append(geompy.addToStudy( Vx, "Vx" ))
  91       entries.append(geompy.addToStudy( Vy, "Vy" ))
  92       entries.append(geompy.addToStudy( Vz, "Vz" ))
  93       entries.append(geompy.addToStudy( origin, "origin" ))
  94
  95       # This part is to automatically display the objects in the active viewer.
  96       gcomp = salome.ImportComponentGUI("GEOM")
  97       for entry in entries:
  98           gcomp.createAndDisplayFitAllGO(entry)
  99
 100
 101   salome_pluginsmanager.AddFunction('DEMO/O,Vx,Vy,Vz (2)',
 102                                     'Creates Basic GEOM objects',
 103                                     trihedron_withdisplay)
 104
 105   # -------------------------------------------------------------------------
 106   # Example 2: creation of a shape with parameters that can be read from a GUI.
 107   # The plugin function (tube_shapewithgui) delegates some action to
 108   # dedicated imported modules (tube.py and tubedialog.py).
 109   #
 110
 111   import tubebuilder
 112   import xalome
 113
 114   # A single dialog box is defined and recycled for every call. The
 115   # fields are initialized with default values given by the tube factory
 116   # tube.py.
 117   import tubedialog
 118   dialog = tubedialog.TubeDialog()
 119   dialog.setData(tubebuilder.DEFAULT_RADIUS,
 120                 tubebuilder.DEFAULT_LENGTH,
 121                 tubebuilder.DEFAULT_WIDTH)
 122
 123   def tube_shapewithgui(context):
 124       global tubebuilder, xalome, dialog
 125       activeStudy = context.study
 126
 127       # Get the parameter values from a gui dialog box. If the dialog is
 128       # closed using the Ok button, then the data are requested from the
 129       # gui and used to create the shape of the tube.
 130       dialog.exec_()
 131       if dialog.wasOk():
 132           radius, length, width = dialog.getData()
 133           shape = tubebuilder.createGeometry(activeStudy, radius, length, width)
 134           entry = xalome.addToStudy(activeStudy, shape, "Tube" )
 135           xalome.displayShape(entry)
 136
 137
 138   salome_pluginsmanager.AddFunction('DEMO/Tube shape from parameters',
 139                                     'Creates a tube object from specified parameters',
 140                                     tube_shapewithgui)
 141
 142
 143   # -------------------------------------------------------------------------
 144   # Example 2 bis: creation of a mesh with parameters that can be read from a GUI.
 145   # The plugin function (tube_meshwithgui) delegates some action to
 146   # dedicated imported modules (tubebuilder.py and tubedialog.py).
 147   #
 148   def tube_meshwithgui(context):
 149       global tube, dialog
 150       activeStudy = context.study
 151
 152       # Get the parameter values from a gui dialog box. If the dialog is
 153       # closed using the Ok button, then the data are requested from the
 154       # gui and used to create the shape of the tube.
 155       dialog.exec_()
 156       if dialog.wasOk():
 157           radius, length, width = dialog.getData()
 158           mesh = tubebuilder.createModel(activeStudy, radius, length, width)
 159
 160
 161   salome_pluginsmanager.AddFunction('DEMO/Tube mesh from parameters',
 162                                     'Creates a tube object from specified parameters',
 163                                     tube_meshwithgui)
 164
 165
 166   # -------------------------------------------------------------------------
 167   # Example 2 ter: creation of a geom object with a preview function in
 168   # the dialog box. This use case is more complex from the gui point of
 169   # view because the dialog box is a not modal so that we can have
 170   # interaction with the complete SALOME application. This modal
 171   # situation requires to connect button click signal on global
 172   # functions as a "callback" mechanism.
 173   #
 174   # TODO:
 175   # - coloring the preview in pink
 176   # - store the tmp study objects in a "preview" folder
 177   #
 178   dialogWithApply = tubedialog.TubeDialogOnTopWithApply()
 179   dialogWithApply.setData(tubebuilder.DEFAULT_RADIUS,
 180                           tubebuilder.DEFAULT_LENGTH,
 181                           tubebuilder.DEFAULT_WIDTH)
 182   activeStudy = None
 183   previewShapeEntry = None
 184
 185   DEFAULT_FOLDER_NAME="TubeList"
 186   DEFAULT_SHAPE_NAME="tube"
 187   PREVIEW_SHAPE_NAME="preview"
 188
 189   def acceptCallback():
 190       """Action to be done when click on Ok"""
 191       global tubebuilder, xalome
 192       global dialogWithApply, activeStudy
 193       global previewShapeEntry, deletePreviewShape
 194       global DEFAULT_FOLDER_NAME,DEFAULT_SHAPE_NAME
 195
 196       dialogWithApply.accept()
 197
 198       if previewShapeEntry is not None:
 199           deletePreviewShape()
 200
 201       radius, length, width = dialogWithApply.getData()
 202       shape = tubebuilder.createGeometry(activeStudy, radius, length, width)
 203       entry = xalome.addToStudy(activeStudy, shape, DEFAULT_SHAPE_NAME, DEFAULT_FOLDER_NAME)
 204       xalome.displayShape(entry)
 205
 206   def rejectCallback():
 207       """Action to be done when click on Cancel"""
 208       global dialogWithApply, previewShapeEntry, deletePreviewShape
 209
 210       dialogWithApply.reject()
 211
 212       if previewShapeEntry is not None:
 213           deletePreviewShape()
 214
 215   import SALOMEDS
 216   PREVIEW_COLOR=SALOMEDS.Color(1,0.6,1) # pink
 217
 218   def applyCallback():
 219       """Action to be done when click on Apply"""
 220       global tubebuilder, xalome
 221       global dialogWithApply, activeStudy
 222       global previewShapeEntry, deletePreviewShape
 223       global PREVIEW_COLOR, DEFAULT_SHAPE_NAME, DEFAULT_FOLDER_NAME, PREVIEW_SHAPE_NAME
 224
 225       # We first have to destroy the currently displayed preview shape.
 226       if previewShapeEntry is not None:
 227           deletePreviewShape()
 228
 229       # Then we can create the new shape with the new parameter values
 230       radius, length, width = dialogWithApply.getData()
 231       shape = tubebuilder.createGeometry(activeStudy, radius, length, width)
 232       # We apply a specific color on the shape for the preview state
 233       shape.SetColor(PREVIEW_COLOR)
 234       previewShapeEntry = xalome.addToStudy(activeStudy, shape, PREVIEW_SHAPE_NAME, DEFAULT_FOLDER_NAME )
 235       xalome.displayShape(previewShapeEntry)
 236
 237   def deletePreviewShape():
 238       """This delete the shape currently being displayed as a preview"""
 239       global activeStudy, previewShapeEntry, xsalome
 240       xalome.deleteShape(activeStudy,previewShapeEntry)
 241       previewShapeEntry = None
 242
 243   # Connection of callback functions to the dialog butoon click signals
 244   dialogWithApply.handleAcceptWith(acceptCallback)
 245   dialogWithApply.handleRejectWith(rejectCallback)
 246   dialogWithApply.handleApplyWith(applyCallback)
 247
 248   def tube_shapewithguiAndPreview(context):
 249       """
 250       This plugin open a dialog in an asynchronous mode. Then it
 251       required callback functions to be associated to the button
 252       signals.
 253       """
 254       global dialogWithApply, activeStudy
 255       activeStudy = context.study
 256       dialogWithApply.open()
 257
 258
 259   salome_pluginsmanager.AddFunction('DEMO/Tube geometry from parameters with preview',
 260                                     'Creates a tube object from specified parameters',
 261                                     tube_shapewithguiAndPreview)
 262
 263
 264
 265 # -------------------------------------------------------------------------
 266 # Example 3: run a shell session in a xterm to get a SALOME python console
 267 def runSalomeShellSession(context):
 268     import os,subprocess
 269     import salome_version
 270     version = salome_version.getVersion(full=True)
 271     kernel_appli_dir = os.environ['KERNEL_ROOT_DIR']
 272     command = ""
 273     if os.path.exists("/usr/bin/gnome-terminal"):
 274       command = 'gnome-terminal -t "SALOME %s - Shell session" -e "%s/salome shell" &'%(version,kernel_appli_dir)
 275     elif os.path.exists("/usr/bin/konsole"):
 276       command = 'PATH="/usr/bin:/sbin:/bin" LD_LIBRARY_PATH="" konsole -e "%s/salome shell" &'%(kernel_appli_dir)
 277     elif os.path.exists("/usr/bin/xterm"):
 278       command = 'xterm -T "SALOME %s - Shell session" -e "%s/salome shell" &'%(version,kernel_appli_dir)
 279     else:
 280       print "Neither xterm nor gnome-terminal nor konsole is installed."
 281
 282     if command is not "":
 283       try:
 284         subprocess.check_call(command, shell = True)
 285       except Exception, e:
 286         print "Error: ",e
 287
 288
 289 salome_pluginsmanager.AddFunction('SALOME shell session',
 290                                   'Execute a SALOME shell session in an external xterm',
 291                                   runSalomeShellSession)