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()
  32
  33     import SMESH, SALOMEDS
  34     from salome.smesh import smeshBuilder
  35     smesh =  smeshBuilder.New()
  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       geompy = geomBuilder.New()
  52
  53       # Create the objects
  54       Vx = geompy.MakeVectorDXDYDZ(10, 0, 0)
  55       Vy = geompy.MakeVectorDXDYDZ(0, 10, 0)
  56       Vz = geompy.MakeVectorDXDYDZ(0, 0, 10)
  57       origin = geompy.MakeVertex(0, 0, 0)
  58
  59       # Register the objects in the active study
  60       geompy.addToStudy( Vx, "Vx" )
  61       geompy.addToStudy( Vy, "Vy" )
  62       geompy.addToStudy( Vz, "Vz" )
  63       geompy.addToStudy( origin, "origin" )
  64
  65
  66   salome_pluginsmanager.AddFunction('DEMO/O,Vx,Vy,Vz',
  67                                     'Creates the trihedron',
  68                                     trihedron)
  69
  70
  71   # -------------------------------------------------------------------------
  72   # Example 1 bis: creation of basic objects and automatic display
  73   def trihedron_withdisplay(context):
  74       import GEOM
  75       from salome.geom import geomBuilder
  76
  77       # Intialize the geompy factory with the active study
  78       geompy = geomBuilder.New()
  79
  80       # Create the objects
  81       Vx = geompy.MakeVectorDXDYDZ(10, 0, 0)
  82       Vy = geompy.MakeVectorDXDYDZ(0, 10, 0)
  83       Vz = geompy.MakeVectorDXDYDZ(0, 0, 10)
  84       origin = geompy.MakeVertex(0, 0, 0)
  85
  86       # Register the objects in the active study
  87       entries=[]
  88       entries.append(geompy.addToStudy( Vx, "Vx" ))
  89       entries.append(geompy.addToStudy( Vy, "Vy" ))
  90       entries.append(geompy.addToStudy( Vz, "Vz" ))
  91       entries.append(geompy.addToStudy( origin, "origin" ))
  92
  93       # This part is to automatically display the objects in the active viewer.
  94       gcomp = salome.ImportComponentGUI("GEOM")
  95       for entry in entries:
  96           gcomp.createAndDisplayFitAllGO(entry)
  97
  98
  99   salome_pluginsmanager.AddFunction('DEMO/O,Vx,Vy,Vz (2)',
 100                                     'Creates Basic GEOM objects',
 101                                     trihedron_withdisplay)
 102
 103   # -------------------------------------------------------------------------
 104   # Example 2: creation of a shape with parameters that can be read from a GUI.
 105   # The plugin function (tube_shapewithgui) delegates some action to
 106   # dedicated imported modules (tube.py and tubedialog.py).
 107   #
 108
 109   import tubebuilder
 110   import xalome
 111
 112   # A single dialog box is defined and recycled for every call. The
 113   # fields are initialized with default values given by the tube factory
 114   # tube.py.
 115   import tubedialog
 116   dialog = tubedialog.TubeDialog()
 117   dialog.setData(tubebuilder.DEFAULT_RADIUS,
 118                 tubebuilder.DEFAULT_LENGTH,
 119                 tubebuilder.DEFAULT_WIDTH)
 120
 121   def tube_shapewithgui(context):
 122       global tubebuilder, xalome, dialog
 123
 124       # Get the parameter values from a gui dialog box. If the dialog is
 125       # closed using the Ok button, then the data are requested from the
 126       # gui and used to create the shape of the tube.
 127       dialog.exec_()
 128       if dialog.wasOk():
 129           radius, length, width = dialog.getData()
 130           shape = tubebuilder.createGeometry(radius, length, width)
 131           entry = xalome.addToStudy(shape, "Tube" )
 132           xalome.displayShape(entry)
 133
 134
 135   salome_pluginsmanager.AddFunction('DEMO/Tube shape from parameters',
 136                                     'Creates a tube object from specified parameters',
 137                                     tube_shapewithgui)
 138
 139
 140   # -------------------------------------------------------------------------
 141   # Example 2 bis: creation of a mesh with parameters that can be read from a GUI.
 142   # The plugin function (tube_meshwithgui) delegates some action to
 143   # dedicated imported modules (tubebuilder.py and tubedialog.py).
 144   #
 145   def tube_meshwithgui(context):
 146       global tube, dialog
 147
 148       # Get the parameter values from a gui dialog box. If the dialog is
 149       # closed using the Ok button, then the data are requested from the
 150       # gui and used to create the shape of the tube.
 151       dialog.exec_()
 152       if dialog.wasOk():
 153           radius, length, width = dialog.getData()
 154           mesh = tubebuilder.createModel(radius, length, width)
 155
 156
 157   salome_pluginsmanager.AddFunction('DEMO/Tube mesh from parameters',
 158                                     'Creates a tube object from specified parameters',
 159                                     tube_meshwithgui)
 160
 161
 162   # -------------------------------------------------------------------------
 163   # Example 2 ter: creation of a geom object with a preview function in
 164   # the dialog box. This use case is more complex from the gui point of
 165   # view because the dialog box is a not modal so that we can have
 166   # interaction with the complete SALOME application. This modal
 167   # situation requires to connect button click signal on global
 168   # functions as a "callback" mechanism.
 169   #
 170   # TODO:
 171   # - coloring the preview in pink
 172   # - store the tmp study objects in a "preview" folder
 173   #
 174   dialogWithApply = tubedialog.TubeDialogOnTopWithApply()
 175   dialogWithApply.setData(tubebuilder.DEFAULT_RADIUS,
 176                           tubebuilder.DEFAULT_LENGTH,
 177                           tubebuilder.DEFAULT_WIDTH)
 178   previewShapeEntry = None
 179
 180   DEFAULT_FOLDER_NAME="TubeList"
 181   DEFAULT_SHAPE_NAME="tube"
 182   PREVIEW_SHAPE_NAME="preview"
 183
 184   def acceptCallback():
 185       """Action to be done when click on Ok"""
 186       global tubebuilder, xalome
 187       global dialogWithApply
 188       global previewShapeEntry, deletePreviewShape
 189       global DEFAULT_FOLDER_NAME,DEFAULT_SHAPE_NAME
 190
 191       dialogWithApply.accept()
 192
 193       if previewShapeEntry is not None:
 194           deletePreviewShape()
 195
 196       radius, length, width = dialogWithApply.getData()
 197       shape = tubebuilder.createGeometry(radius, length, width)
 198       entry = xalome.addToStudy(shape, DEFAULT_SHAPE_NAME, DEFAULT_FOLDER_NAME)
 199       xalome.displayShape(entry)
 200
 201   def rejectCallback():
 202       """Action to be done when click on Cancel"""
 203       global dialogWithApply, previewShapeEntry, deletePreviewShape
 204
 205       dialogWithApply.reject()
 206
 207       if previewShapeEntry is not None:
 208           deletePreviewShape()
 209
 210   import SALOMEDS
 211   PREVIEW_COLOR=SALOMEDS.Color(1,0.6,1) # pink
 212
 213   def applyCallback():
 214       """Action to be done when click on Apply"""
 215       global tubebuilder, xalome
 216       global dialogWithApply
 217       global previewShapeEntry, deletePreviewShape
 218       global PREVIEW_COLOR, DEFAULT_SHAPE_NAME, DEFAULT_FOLDER_NAME, PREVIEW_SHAPE_NAME
 219
 220       # We first have to destroy the currently displayed preview shape.
 221       if previewShapeEntry is not None:
 222           deletePreviewShape()
 223
 224       # Then we can create the new shape with the new parameter values
 225       radius, length, width = dialogWithApply.getData()
 226       shape = tubebuilder.createGeometry(radius, length, width)
 227       # We apply a specific color on the shape for the preview state
 228       shape.SetColor(PREVIEW_COLOR)
 229       previewShapeEntry = xalome.addToStudy(shape, PREVIEW_SHAPE_NAME, DEFAULT_FOLDER_NAME )
 230       xalome.displayShape(previewShapeEntry)
 231
 232   def deletePreviewShape():
 233       """This delete the shape currently being displayed as a preview"""
 234       global previewShapeEntry, xsalome
 235       xalome.deleteShape(previewShapeEntry)
 236       previewShapeEntry = None
 237
 238   # Connection of callback functions to the dialog butoon click signals
 239   dialogWithApply.handleAcceptWith(acceptCallback)
 240   dialogWithApply.handleRejectWith(rejectCallback)
 241   dialogWithApply.handleApplyWith(applyCallback)
 242
 243   def tube_shapewithguiAndPreview(context):
 244       """
 245       This plugin open a dialog in an asynchronous mode. Then it
 246       required callback functions to be associated to the button
 247       signals.
 248       """
 249       global dialogWithApply
 250       dialogWithApply.open()
 251
 252
 253   salome_pluginsmanager.AddFunction('DEMO/Tube geometry from parameters with preview',
 254                                     'Creates a tube object from specified parameters',
 255                                     tube_shapewithguiAndPreview)
 256
 257
 258
 259 # -------------------------------------------------------------------------
 260 # Example 3: run a shell session in a xterm to get a SALOME python console
 261 def runSalomeShellSession(context):
 262     import os,subprocess
 263     import salome_version
 264     version = salome_version.getVersion(full=True)
 265     kernel_appli_dir = os.environ['KERNEL_ROOT_DIR']
 266     command = ""
 267     if os.path.exists("/usr/bin/gnome-terminal"):
 268       command = 'gnome-terminal -t "SALOME %s - Shell session" -e "%s/salome shell" &'%(version,kernel_appli_dir)
 269     elif os.path.exists("/usr/bin/konsole"):
 270       command = 'PATH="/usr/bin:/sbin:/bin" LD_LIBRARY_PATH="" konsole -e "%s/salome shell" &'%(kernel_appli_dir)
 271     elif os.path.exists("/usr/bin/xterm"):
 272       command = 'xterm -T "SALOME %s - Shell session" -e "%s/salome shell" &'%(version,kernel_appli_dir)
 273     else:
 274       print("Neither xterm nor gnome-terminal nor konsole is installed.")
 275
 276     if command is not "":
 277       try:
 278         subprocess.check_call(command, shell = True)
 279       except Exception as e:
 280         print("Error: ",e)
 281
 282
 283 salome_pluginsmanager.AddFunction('SALOME shell session',
 284                                   'Execute a SALOME shell session in an external xterm',
 285                                   runSalomeShellSession)