src/MEDOP/doc/sphinx/salomedoc.rst

   1 .. meta::
   2    :keywords: SALOME, development
   3    :author: Guillaume Boulant
   4
   5 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
   6 Annexe : Règles de développement SALOME
   7 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
   8
   9 Cette annexe est un recueil de techniques de développement spécifiques
  10 à l'environnement SALOME et utilisées pour la mise au point du module
  11 XMED. Elles sont a priori utilisables pour d'autres contexte de
  12 développement dans SALOME.
  13
  14 .. TODO: récupérer les fonctions génériques de VisuGUI_Tools.cxx
  15 .. TODO: récupérer les fonctions génériques de SMESGGUI_utils.cxx
  16
  17 .. contents:: Sommaire
  18    :local:
  19    :backlinks: none
  20
  21 Récupérer la sélection dans l'arbre d'étude
  22 ===========================================
  23
  24 Dans une classe dérivée de ``SalomeApp_Module``, on peut utiliser un
  25 code de la forme suivante:
  26
  27 .. code-block:: cpp
  28
  29  #include <SALOME_ListIO.hxx>
  30  #include <LightApp_SelectionMgr.h>
  31  #include <SALOME_ListIteratorOfListIO.hxx>
  32  #include <SALOME_InteractiveObject.hxx>
  33
  34  // ...
  35
  36  // Get the selected object in the study (SObject)
  37  LightApp_SelectionMgr* aSelectionMgr = this->getApp()->selectionMgr();
  38  SALOME_ListIO aListIO;
  39  aSelectionMgr->selectedObjects(aListIO);
  40
  41  // Analyse the selection. There can be more than one item.
  42  SALOME_ListIteratorOfListIO It (aListIO);
  43  for (; It.More(); It.Next()) {
  44    Handle(SALOME_InteractiveObject) anIO = It.Value();
  45    SALOMEDS::SObject_var aSObject = aStudy->FindObjectID(anIO->getEntry());
  46
  47    // Check if the selected object is relevant for the operation
  48    // ...
  49
  50    // Process the SObject if it's relevant
  51    // ...
  52
  53  }
  54
  55 On peut noter qu'une variable ``aStudy`` est requise. Elle représente
  56 l'étude SALOME sur laquelle s'oppère la sélection. L'étude active
  57 (impliquée dans la sélection) peut être obtenue au moyen du
  58 gestionnaire d'étude (voir :ref:`ci-dessous <salomedoc_getActiveStudy>`).
  59
  60 Réglage du curseur graphique
  61 ============================
  62
  63 Dans le cas où le traitement est long, il peut être intéressant
  64 d'encadrer l'opération par un vérouillage du curseur de sélection:
  65
  66 .. code-block:: cpp
  67
  68  QApplication::setOverrideCursor(Qt::WaitCursor);
  69
  70  // Do the job
  71  // ...
  72
  73  QApplication::restoreOverrideCursor();
  74
  75
  76 Les variables pour la gestion de l'étude
  77 ========================================
  78
  79 Les variables CORBA
  80 -------------------
  81
  82 Les variables CORBA comme le serveur de noms (naming service) et le
  83 gestionnaire de cycle de vie des objets (LifeCycleCRORBA) sont
  84 fréquement utilisés. Dans le contexte d'une application (classe de
  85 type ``SalomeApp_Module``), il est possible de récupérer simplement
  86 des instances de ces variables par les commandes suivantes:
  87
  88 .. code-block:: cpp
  89
  90    #include <SalomeApp_Application.h>
  91    #include <SALOME_NamingService.hxx>
  92
  93    CORBA::ORB_var               orb           = SalomeApp_Application::orb();
  94    SALOMEDSClient_StudyManager* studyMgr      = SalomeApp_Application::studyMgr();
  95    SALOME_NamingService*        namingService = SalomeApp_Application::namingService();
  96    SALOME_LifeCycleCORBA*       lcc           = SalomeApp_Application::lcc();
  97
  98 Pour un usage en dehors de l'application graphique (par exemple au
  99 niveau du container), l'orb peut être obtenu par les mécanismes
 100 standard d'omniORB:
 101
 102 .. code-block:: cpp
 103
 104    CORBA::ORB_var orb = CORBA::ORB_init(0,0);
 105
 106 L'orb est par exemple utile à récupérer pour la sérialisation des
 107 objets CORBA et la manipulation des références sous forme de chaîne de
 108 caractères:
 109
 110 .. code-block:: cpp
 111
 112    // We suppose here that we have a CORBA object reference (object of
 113    // type *_ptr or *_var), for example a SALOME_MED::MED object.
 114    SALOME_MED::MED_ptr medObj = ... // anything to get this object
 115    QString medIOR = orb->object_to_string(medObj);
 116
 117    SALOME_MED::MED_ptr anOtherRefToMedObj = orb->string_to_object(medIOR)
 118
 119 .. note: this serialization can be used to communicate between a GUI
 120    and a component in a container, or between the C++ context and the
 121    python context.
 122
 123 .. _salomedoc_getActiveStudy:
 124
 125 Récupérer l'étude active
 126 ------------------------
 127
 128 Le concept d'étude active est un concept GUI. Il désigne l'étude en
 129 cours d'usage au niveau de l'interface graphique.
 130
 131 .. note: Pour rappel, l'étude est un objet CORBA de type
 132    ``SALOMEDS::Study`` qui héberge physiquement les ``SObject``
 133    pointant vers les données. L'arbre d'étude ("Object browser") est
 134    une représentation graphique de cet objet.
 135
 136 L'étude active peut être obtenue au moyen du gestionnaire
 137 d'étude. Dans le corps d'une classe de type ``SalomeApp_Module``, ceci
 138 peut se faire par un code de la forme suivante:
 139
 140 .. code-block:: cpp
 141
 142   #include "SALOMEconfig.h"
 143   #include CORBA_SERVER_HEADER(SALOMEDS)
 144   #include <SalomeApp_Application.h>
 145   #include <SALOME_NamingService.hxx>
 146
 147   // ...
 148
 149   // Get the study id of the active study
 150   SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*> (this->getApp()->activeStudy());
 151   _PTR(Study) aCStudy = appStudy->studyDS();
 152   int aStudyID = aCStudy->StudyId();
 153
 154   // Then get the study manager
 155   SALOME_NamingService *aNamingService = SalomeApp_Application::namingService();
 156   CORBA::Object_var anObject = aNamingService->Resolve("/myStudyManager");
 157   SALOMEDS::StudyManager_var aStudyManager = SALOMEDS::StudyManager::_narrow(anObject);
 158
 159   // Finally, request the study manager for the study (SALOMEDS::Study)
 160   SALOMEDS::Study_var aStudy = aStudyManager->GetStudyByID(aStudyID);
 161
 162
 163 Communiquer avec la console python
 164 ==================================
 165
 166 La console python désigne l'interpréteur embarqué dans l'interface
 167 graphique de SALOME (GUI). Elle est également désignée comme
 168 l'interface textuelle de SALOME (TUI) car elle permet de piloter
 169 SALOME au moyen de commandes en syntaxe python.
 170
 171 Le paragraphe montre comment communiquer avec cette interface texte
 172 depuis le contexte C++ de l'interface graphique, en particulier pour
 173 déclencher l'exécution de commandes.
 174
 175 Le code se situe donc au sein d'une classe de type
 176 ``SalomeApp_Module`` (de laquelle hérite la partie graphique d'un
 177 module SALOME, de nom ``<MODULE_NAME>GUI``). Cette classe possède une
 178 méthode ``getApp()`` par laquelle on peut récupérer une instance de la
 179 console python embarquée (this->getApp()->pythonConsole()).
 180
 181 Le code suivant illustre l'envoie d'une commande python par ce
 182 mécanisme. Dans cette exemple, on défini une variable ``id`` dans la
 183 console python comme l'identifiant de l'étude active:
 184
 185 .. code-block:: cpp
 186
 187    #include <PyConsole_Console.h>
 188    #include <QString>
 189    #include <QStringList>
 190
 191    PyConsole_Console * pyConsole = getApp()->pythonConsole();
 192
 193    QStringList commands;
 194    commands+="import salome";
 195    commands+="id=salome.myStudyId";
 196
 197    QStringListIterator it(commands);
 198    while (it.hasNext()) {
 199        pyConsole->exec(it.next());
 200    }
 201
 202 Dans ce deuxième exemple, on cherche à reconstituer dans le contexte
 203 de la console python un pointer vers un objet med instancié dans le
 204 contexte C++ de l'application graphique. Pour cela, on communique la
 205 référence de l'objet sous la forme sérialisé (IOR pour un objet
 206 CORBA):
 207
 208 .. code-block:: cpp
 209
 210    #include <PyConsole_Console.h>
 211    #include <QString>
 212    #include <QStringList>
 213    #include <SalomeApp_Application.h>
 214
 215    // We suppose here that we have a CORBA object reference (object of
 216    // type *_ptr or *_var), for example a SALOME_MED::MED object.
 217    SALOME_MED::MED_ptr medObj = ... // anything to get this object
 218
 219    // Get the IOR of this object
 220    QString medIOR = SalomeApp_Application::orb()->object_to_string(medObj);
 221
 222    PyConsole_Console * pyConsole = getApp()->pythonConsole();
 223
 224    QStringList commands;
 225    commands+="import salome";
 226    commands+=QString("med=salome.orb.string_to_object(\"%1\")").arg(medIOR);
 227
 228    QStringListIterator it(commands);
 229    while (it.hasNext()) {
 230        pyConsole->exec(it.next());
 231    }