Salome HOME
0022876: EDF 8425 SMESH: Get the normal of a face in the GUI
[modules/smesh.git] / src / SMESHGUI / SMESHGUI_MeshInfo.cxx
1 // Copyright (C) 2007-2015  CEA/DEN, EDF R&D, OPEN CASCADE
2 //
3 // Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
4 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
5 //
6 // This library is free software; you can redistribute it and/or
7 // modify it under the terms of the GNU Lesser General Public
8 // License as published by the Free Software Foundation; either
9 // version 2.1 of the License, or (at your option) any later version.
10 //
11 // This library is distributed in the hope that it will be useful,
12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14 // Lesser General Public License for more details.
15 //
16 // You should have received a copy of the GNU Lesser General Public
17 // License along with this library; if not, write to the Free Software
18 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
19 //
20 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
21 //
22 //  File   : SMESHGUI_MeshInfo.cxx
23 //  Author : Vadim SANDLER, Open CASCADE S.A.S. (vadim.sandler@opencascade.com)
24
25 #include "SMESHGUI_MeshInfo.h"
26
27 #include "SMDSAbs_ElementType.hxx"
28 #include "SMDS_BallElement.hxx"
29 #include "SMDS_EdgePosition.hxx"
30 #include "SMDS_FacePosition.hxx"
31 #include "SMDS_Mesh.hxx"
32 #include "SMDS_VolumeTool.hxx"
33 #include "SMESHDS_Mesh.hxx"
34 #include "SMESHGUI.h"
35 #include "SMESHGUI_FilterUtils.h"
36 #include "SMESHGUI_IdValidator.h"
37 #include "SMESHGUI_SpinBox.h"
38 #include "SMESHGUI_Utils.h"
39 #include "SMESHGUI_VTKUtils.h"
40 #include "SMESH_Actor.h"
41
42 #include <LightApp_SelectionMgr.h>
43 #include <SUIT_FileDlg.h>
44 #include <SUIT_OverrideCursor.h>
45 #include <SUIT_ResourceMgr.h>
46 #include <SUIT_Session.h>
47 #include <SVTK_ViewWindow.h>
48
49 #include <SALOMEDSClient_Study.hxx>
50 #include <SalomeApp_Study.h>
51
52 #include <QApplication>
53 #include <QButtonGroup>
54 #include <QCheckBox>
55 #include <QContextMenuEvent>
56 #include <QGridLayout>
57 #include <QHBoxLayout>
58 #include <QHeaderView>
59 #include <QItemDelegate>
60 #include <QKeyEvent>
61 #include <QLabel>
62 #include <QLineEdit>
63 #include <QMenu>
64 #include <QPushButton>
65 #include <QToolButton>
66 #include <QRadioButton>
67 #include <QTextStream>
68 #include <QTabWidget>
69 #include <QTextBrowser>
70 #include <QVBoxLayout>
71
72 #include "utilities.h"
73
74 #include <SALOMEconfig.h>
75 #include CORBA_SERVER_HEADER(GEOM_Gen)
76
77 namespace {
78
79 const int SPACING      = 6;
80 const int MARGIN       = 9;
81 const int MAXITEMS     = 10;
82 const int GROUPS_ID    = 100;
83 const int SUBMESHES_ID = 200;
84 const int SPACING_INFO = 2;
85
86 enum InfoRole {
87   TypeRole = Qt::UserRole + 10,
88   IdRole,
89 };
90
91 enum InfoType {
92   NodeConnectivity = 100,
93   ElemConnectivity,
94 };
95 } // namesapce
96
97 /*!
98   \class ExtraWidget
99   \internal
100 */
101 class ExtraWidget : public QWidget
102 {
103 public:
104   ExtraWidget( QWidget*, bool = false );
105   ~ExtraWidget();
106
107   void updateControls( int, int, int = MAXITEMS );
108
109 public:
110   QLabel*      current;
111   QPushButton* prev;
112   QPushButton* next;
113   bool         brief;
114 };
115
116 ExtraWidget::ExtraWidget( QWidget* parent, bool b ) : QWidget( parent ), brief( b )
117 {
118   current = new QLabel( this );
119   current->setAlignment( Qt::AlignRight | Qt::AlignVCenter );
120   prev = new QPushButton( tr( "<<" ), this );
121   next = new QPushButton( tr( ">>" ), this );
122   QHBoxLayout* hbl = new QHBoxLayout( this );
123   hbl->setContentsMargins( 0, SPACING, 0, 0 );
124   hbl->setSpacing( SPACING );
125   hbl->addStretch();
126   hbl->addWidget( current );
127   hbl->addWidget( prev );
128   hbl->addWidget( next );
129 }
130
131 ExtraWidget::~ExtraWidget()
132 {
133 }
134
135 void ExtraWidget::updateControls( int total, int index, int blockSize )
136 {
137   setVisible( total > blockSize );
138   QString format = brief ? QString( "%1-%2 / %3" ) : SMESHGUI_MeshInfoDlg::tr( "X_FROM_Y_ITEMS_SHOWN" );
139   current->setText( format.arg( index*blockSize+1 ).arg( qMin( index*blockSize+blockSize, total ) ).arg( total ) );
140   prev->setEnabled( index > 0 );
141   next->setEnabled( (index+1)*blockSize < total );
142 }
143
144 /*!
145   \class DumpFileDlg
146   \brief Customization of standard "Save file" dialog box for dump info operation
147   \internal
148 */
149
150 class DumpFileDlg : public SUIT_FileDlg
151 {
152 public:
153   DumpFileDlg( QWidget* parent );
154
155   QCheckBox* myBaseChk;
156   QCheckBox* myElemChk;
157   QCheckBox* myAddChk;
158   QCheckBox* myCtrlChk;
159 };
160
161 /*!
162   \brief Constructor
163   \internal
164 */
165 DumpFileDlg::DumpFileDlg( QWidget* parent ) : SUIT_FileDlg( parent, false, true, true )
166 {
167   QGridLayout* grid = ::qobject_cast<QGridLayout *>( layout() );
168   if ( grid ) {
169     QWidget* hB = new QWidget( this );
170     myBaseChk = new QCheckBox( SMESHGUI::tr( "PREF_DUMP_BASE_INFO" ), hB );
171     myElemChk = new QCheckBox( SMESHGUI::tr( "PREF_DUMP_ELEM_INFO" ), hB );
172     myAddChk  = new QCheckBox( SMESHGUI::tr( "PREF_DUMP_ADD_INFO" ),  hB );
173     myCtrlChk = new QCheckBox( SMESHGUI::tr( "PREF_DUMP_CTRL_INFO" ), hB );
174
175     QGridLayout* layout = new QGridLayout( hB );
176     layout->addWidget( myBaseChk, 0, 0 );
177     layout->addWidget( myElemChk, 0, 1 );
178     layout->addWidget( myAddChk, 1, 0 );
179     layout->addWidget( myCtrlChk, 1, 1 );
180
181     QPushButton* pb = new QPushButton( this );
182
183     int row = grid->rowCount();
184     grid->addWidget( new QLabel( "", this ), row, 0 );
185     grid->addWidget( hB, row, 1, 1, 3 );
186     grid->addWidget( pb, row, 5 );
187
188     pb->hide();
189   }
190 }
191
192 /*!
193   \brief Get depth of the tree item
194   \internal
195   \param theItem tree widget item
196   \return item's depth in tree widget (where top-level items have zero depth)
197 */
198 static int itemDepth( QTreeWidgetItem* item )
199 {
200   int d = 0;
201   QTreeWidgetItem* p = item->parent();
202   while ( p ) {
203     d++;
204     p = p->parent();
205   }
206   return d;
207 }
208
209 /*!
210   \class SMESHGUI_MeshInfo
211   \brief Base mesh information widget
212   
213   Displays the base information about mesh object: mesh, sub-mesh, group or arbitrary ID source.
214 */
215
216 /*!
217   \brief Constructor.
218   \param parent parent widget
219 */
220 SMESHGUI_MeshInfo::SMESHGUI_MeshInfo( QWidget* parent )
221   : QFrame( parent ), myWidgets( iElementsEnd )
222 {
223   setFrameStyle( StyledPanel | Sunken );
224
225   QGridLayout* l = new QGridLayout( this );
226   l->setMargin( MARGIN );
227   l->setSpacing( SPACING );
228
229   int index = 0;
230
231   // object
232   QLabel* aNameLab     = new QLabel( tr( "NAME_LAB" ), this );
233   QLabel* aName        = createField();
234   aName->setMinimumWidth( 150 );
235   QLabel* aObjLab      = new QLabel( tr( "OBJECT_LAB" ), this );
236   QLabel* aObj         = createField();
237   aObj->setMinimumWidth( 150 );
238   myWidgets[ index++ ] << aNameLab << aName;
239   myWidgets[ index++ ] << aObjLab  << aObj;
240
241   // nodes
242   QWidget* aNodesLine  = createLine();
243   QLabel*  aNodesLab   = new QLabel( tr( "NODES_LAB" ), this );
244   QLabel*  aNodes      = createField();
245   myWidgets[ index++ ] << aNodesLine;
246   myWidgets[ index++ ] << aNodesLab << aNodes;
247
248   // elements
249   QWidget* aElemLine   = createLine();
250   QLabel*  aElemLab    = new QLabel( tr( "ELEMENTS_LAB" ),     this );
251   QLabel*  aElemTotal  = new QLabel( tr( "TOTAL_LAB" ),        this );
252   QLabel*  aElemLin    = new QLabel( tr( "LINEAR_LAB" ),       this );
253   QLabel*  aElemQuad   = new QLabel( tr( "QUADRATIC_LAB" ),    this );
254   QLabel*  aElemBiQuad = new QLabel( tr( "BI_QUADRATIC_LAB" ), this );
255   myWidgets[ index++ ] << aElemLine;
256   myWidgets[ index++ ] << aElemLab << aElemTotal << aElemLin << aElemQuad << aElemBiQuad;
257
258   // ... Number elements
259   QWidget* aNbLine     = createLine(); 
260   QLabel*  aNbTotal    = createField();
261   QLabel*  aNbLin      = createField();
262   QLabel*  aNbQuad     = createField();
263   QLabel*  aNbBiQuad   = createField();
264   myWidgets[ index++ ] << aNbLine;
265   myWidgets[ index++ ] << new QLabel( "", this ) << aNbTotal << aNbLin << aNbQuad << aNbBiQuad;
266
267   // ... 0D elements
268   QWidget* a0DLine     = createLine();
269   QLabel*  a0DLab      = new QLabel( tr( "0D_LAB" ), this );
270   QLabel*  a0DTotal    = createField();
271   myWidgets[ index++ ] << a0DLine;
272   myWidgets[ index++ ] << a0DLab << a0DTotal;
273
274   // ... Ball elements
275   QWidget* aBallLine     = createLine();
276   QLabel*  aBallLab      = new QLabel( tr( "BALL_LAB" ), this );
277   QLabel*  aBallTotal    = createField();
278   myWidgets[ index++ ] << aBallLine;
279   myWidgets[ index++ ] << aBallLab << aBallTotal;
280
281   // ... 1D elements
282   QWidget* a1DLine     = createLine();
283   QLabel*  a1DLab      = new QLabel( tr( "1D_LAB" ), this );
284   QLabel*  a1DTotal    = createField();
285   QLabel*  a1DLin      = createField();
286   QLabel*  a1DQuad     = createField();
287   myWidgets[ index++ ] << a1DLine;
288   myWidgets[ index++ ] << a1DLab << a1DTotal << a1DLin << a1DQuad;
289
290   // ... 2D elements
291   QWidget* a2DLine      = createLine();
292   QLabel*  a2DLab       = new QLabel( tr( "2D_LAB" ), this );
293   QLabel*  a2DTotal     = createField();
294   QLabel*  a2DLin       = createField();
295   QLabel*  a2DQuad      = createField();
296   QLabel*  a2DBiQuad    = createField();
297   QLabel*  a2DTriLab    = new QLabel( tr( "TRIANGLES_LAB" ), this );
298   QLabel*  a2DTriTotal  = createField();
299   QLabel*  a2DTriLin    = createField();
300   QLabel*  a2DTriQuad   = createField();
301   QLabel*  a2DTriBiQuad = createField();
302   QLabel*  a2DQuaLab    = new QLabel( tr( "QUADRANGLES_LAB" ), this );
303   QLabel*  a2DQuaTotal  = createField();
304   QLabel*  a2DQuaLin    = createField();
305   QLabel*  a2DQuaQuad   = createField();
306   QLabel*  a2DQuaBiQuad = createField();
307   QLabel*  a2DPolLab    = new QLabel( tr( "POLYGONS_LAB" ), this );
308   QLabel*  a2DPolTotal  = createField();
309   myWidgets[ index++ ] << a2DLine;
310   myWidgets[ index++ ] << a2DLab    << a2DTotal    << a2DLin    << a2DQuad    << a2DBiQuad;
311   myWidgets[ index++ ] << a2DTriLab << a2DTriTotal << a2DTriLin << a2DTriQuad << a2DTriBiQuad;
312   myWidgets[ index++ ] << a2DQuaLab << a2DQuaTotal << a2DQuaLin << a2DQuaQuad << a2DQuaBiQuad;
313   myWidgets[ index++ ] << a2DPolLab << a2DPolTotal;
314
315   // ... 3D elements
316   QWidget* a3DLine      = createLine();
317   QLabel*  a3DLab       = new QLabel( tr( "3D_LAB" ), this );
318   QLabel*  a3DTotal     = createField();
319   QLabel*  a3DLin       = createField();
320   QLabel*  a3DQuad      = createField();
321   QLabel*  a3DBiQuad    = createField();
322   QLabel*  a3DTetLab    = new QLabel( tr( "TETRAHEDRONS_LAB" ), this );
323   QLabel*  a3DTetTotal  = createField();
324   QLabel*  a3DTetLin    = createField();
325   QLabel*  a3DTetQuad   = createField();
326   QLabel*  a3DHexLab    = new QLabel( tr( "HEXAHEDONRS_LAB" ), this );
327   QLabel*  a3DHexTotal  = createField();
328   QLabel*  a3DHexLin    = createField();
329   QLabel*  a3DHexQuad   = createField();
330   QLabel*  a3DHexBiQuad = createField();
331   QLabel*  a3DPyrLab    = new QLabel( tr( "PYRAMIDS_LAB" ), this );
332   QLabel*  a3DPyrTotal  = createField();
333   QLabel*  a3DPyrLin    = createField();
334   QLabel*  a3DPyrQuad   = createField();
335   QLabel*  a3DPriLab    = new QLabel( tr( "PRISMS_LAB" ), this );
336   QLabel*  a3DPriTotal  = createField();
337   QLabel*  a3DPriLin    = createField();
338   QLabel*  a3DPriQuad   = createField();
339   QLabel*  a3DHexPriLab   = new QLabel( tr( "HEX_PRISMS_LAB" ), this );
340   QLabel*  a3DHexPriTotal = createField();
341   QLabel*  a3DPolLab    = new QLabel( tr( "POLYHEDRONS_LAB" ), this );
342   QLabel*  a3DPolTotal  = createField();
343   myWidgets[ index++ ] << a3DLine;
344   myWidgets[ index++ ] << a3DLab    << a3DTotal    << a3DLin    << a3DQuad    << a3DBiQuad;
345   myWidgets[ index++ ] << a3DTetLab << a3DTetTotal << a3DTetLin << a3DTetQuad;
346   myWidgets[ index++ ] << a3DHexLab << a3DHexTotal << a3DHexLin << a3DHexQuad << a3DHexBiQuad;
347   myWidgets[ index++ ] << a3DPyrLab << a3DPyrTotal << a3DPyrLin << a3DPyrQuad;
348   myWidgets[ index++ ] << a3DPriLab << a3DPriTotal << a3DPriLin << a3DPriQuad;
349   myWidgets[ index++ ] << a3DHexPriLab << a3DHexPriTotal;
350   myWidgets[ index++ ] << a3DPolLab << a3DPolTotal;
351
352   myLoadBtn = new QPushButton( tr( "BUT_LOAD_MESH" ), this );
353   myLoadBtn->setAutoDefault( true );
354   connect( myLoadBtn, SIGNAL( clicked() ), this, SLOT( loadMesh() ) );
355   
356   setFontAttributes( aNameLab,    Bold );
357   setFontAttributes( aObjLab,     Bold );
358   setFontAttributes( aNodesLab,   Bold );
359   setFontAttributes( aElemLab,    Bold );
360   setFontAttributes( aElemTotal,  Italic );
361   setFontAttributes( aElemLin,    Italic );
362   setFontAttributes( aElemQuad,   Italic );
363   setFontAttributes( aElemBiQuad, Italic );
364   setFontAttributes( a0DLab,      Bold );
365   setFontAttributes( aBallLab,    Bold );
366   setFontAttributes( a1DLab,      Bold );
367   setFontAttributes( a2DLab,      Bold );
368   setFontAttributes( a3DLab,      Bold );
369
370   l->addWidget( aNameLab,     0, 0 );
371   l->addWidget( aName,        0, 1, 1, 4 );
372   l->addWidget( aObjLab,      1, 0 );
373   l->addWidget( aObj,         1, 1, 1, 4 );
374   l->addWidget( aNodesLine,   2, 0, 1, 5 );
375   l->addWidget( aNodesLab,    3, 0 );
376   l->addWidget( aNodes,       3, 1 );
377   l->addWidget( aElemLine,    4, 0, 1, 5 );
378   l->addWidget( aElemLab,     5, 0 );
379   l->addWidget( aElemTotal,   5, 1 );
380   l->addWidget( aElemLin,     5, 2 );
381   l->addWidget( aElemQuad,    5, 3 );
382   l->addWidget( aElemBiQuad,  5, 4 );
383   l->addWidget( aNbLine,      6, 1, 1, 4 );
384   l->addWidget( aNbTotal,     7, 1 );
385   l->addWidget( aNbLin,       7, 2 );
386   l->addWidget( aNbQuad,      7, 3 );
387   l->addWidget( aNbBiQuad,    7, 4 );
388   l->addWidget( a0DLine,      8, 1, 1, 4 );
389   l->addWidget( a0DLab,       9, 0 );
390   l->addWidget( a0DTotal,     9, 1 );
391   l->addWidget( aBallLine,    10, 1, 1, 4 );
392   l->addWidget( aBallLab,     11, 0 );
393   l->addWidget( aBallTotal,   11, 1 );
394   l->addWidget( a1DLine,      12, 1, 1, 4 );
395   l->addWidget( a1DLab,       13, 0 );
396   l->addWidget( a1DTotal,     13, 1 );
397   l->addWidget( a1DLin,       13, 2 );
398   l->addWidget( a1DQuad,      13, 3 );
399   l->addWidget( a2DLine,      14, 1, 1, 4 );
400   l->addWidget( a2DLab,       15, 0 );
401   l->addWidget( a2DTotal,     15, 1 );
402   l->addWidget( a2DLin,       15, 2 );
403   l->addWidget( a2DQuad,      15, 3 );
404   l->addWidget( a2DBiQuad,    15, 4 );
405   l->addWidget( a2DTriLab,    16, 0 );
406   l->addWidget( a2DTriTotal,  16, 1 );
407   l->addWidget( a2DTriLin,    16, 2 );
408   l->addWidget( a2DTriQuad,   16, 3 );
409   l->addWidget( a2DTriBiQuad, 16, 4 );
410   l->addWidget( a2DQuaLab,    17, 0 );
411   l->addWidget( a2DQuaTotal,  17, 1 );
412   l->addWidget( a2DQuaLin,    17, 2 );
413   l->addWidget( a2DQuaQuad,   17, 3 );
414   l->addWidget( a2DQuaBiQuad, 17, 4 );
415   l->addWidget( a2DPolLab,    18, 0 );
416   l->addWidget( a2DPolTotal,  18, 1 );
417   l->addWidget( a3DLine,      19, 1, 1, 4 );
418   l->addWidget( a3DLab,       20, 0 );
419   l->addWidget( a3DTotal,     20, 1 );
420   l->addWidget( a3DLin,       20, 2 );
421   l->addWidget( a3DQuad,      20, 3 );
422   l->addWidget( a3DBiQuad,    20, 4 );
423   l->addWidget( a3DTetLab,    21, 0 );
424   l->addWidget( a3DTetTotal,  21, 1 );
425   l->addWidget( a3DTetLin,    21, 2 );
426   l->addWidget( a3DTetQuad,   21, 3 );
427   l->addWidget( a3DHexLab,    22, 0 );
428   l->addWidget( a3DHexTotal,  22, 1 );
429   l->addWidget( a3DHexLin,    22, 2 );
430   l->addWidget( a3DHexQuad,   22, 3 );
431   l->addWidget( a3DHexBiQuad, 22, 4 );
432   l->addWidget( a3DPyrLab,    23, 0 );
433   l->addWidget( a3DPyrTotal,  23, 1 );
434   l->addWidget( a3DPyrLin,    23, 2 );
435   l->addWidget( a3DPyrQuad,   23, 3 );
436   l->addWidget( a3DPriLab,    24, 0 );
437   l->addWidget( a3DPriTotal,  24, 1 );
438   l->addWidget( a3DPriLin,    24, 2 );
439   l->addWidget( a3DPriQuad,   24, 3 );
440   l->addWidget( a3DHexPriLab,   25, 0 );
441   l->addWidget( a3DHexPriTotal, 25, 1 );
442   l->addWidget( a3DPolLab,    26, 0 );
443   l->addWidget( a3DPolTotal,  26, 1 );
444   l->addWidget( myLoadBtn,    28, 1, 1, 4 );
445
446   l->setColumnStretch( 0, 0 );
447   l->setColumnStretch( 1, 5 );
448   l->setColumnStretch( 2, 5 );
449   l->setColumnStretch( 3, 5 );
450   l->setColumnStretch( 4, 5 );
451   l->setRowStretch( 27, 5 );
452
453   clear();
454 }
455
456 /*!
457   \brief Destructor
458 */
459 SMESHGUI_MeshInfo::~SMESHGUI_MeshInfo()
460 {
461 }
462
463 /*!
464   \brief Show information on the mesh object.
465   \param obj object being processed (mesh, sub-mesh, group, ID source)
466 */
467 void SMESHGUI_MeshInfo::showInfo( SMESH::SMESH_IDSource_ptr obj )
468 {
469   clear();
470   if ( !CORBA::is_nil( obj ) ) {
471     _PTR(SObject) sobj = SMESH::ObjectToSObject( obj );
472     if ( sobj ) 
473       myWidgets[iName][iSingle]->setProperty( "text", sobj->GetName().c_str() );
474     SMESH::SMESH_Mesh_var      aMesh    = SMESH::SMESH_Mesh::_narrow( obj );
475     SMESH::SMESH_subMesh_var   aSubMesh = SMESH::SMESH_subMesh::_narrow( obj );
476     SMESH::SMESH_GroupBase_var aGroup   = SMESH::SMESH_GroupBase::_narrow( obj );
477     if ( !aMesh->_is_nil() ) {
478       myWidgets[iObject][iSingle]->setProperty( "text", tr( "OBJECT_MESH" ) );
479     }
480     else if ( !aSubMesh->_is_nil() ) {
481       myWidgets[iObject][iSingle]->setProperty( "text", tr( "OBJECT_SUBMESH" ) );
482     }
483     else if ( !aGroup->_is_nil() ) {
484       QString objType;
485       switch( aGroup->GetType() ) {
486       case SMESH::NODE:  objType = tr( "OBJECT_GROUP_NODES"   );break;
487       case SMESH::EDGE:  objType = tr( "OBJECT_GROUP_EDGES"   );break;
488       case SMESH::FACE:  objType = tr( "OBJECT_GROUP_FACES"   );break;
489       case SMESH::VOLUME:objType = tr( "OBJECT_GROUP_VOLUMES" );break;
490       case SMESH::ELEM0D:objType = tr( "OBJECT_GROUP_0DELEMS" );break;
491       case SMESH::BALL:  objType = tr( "OBJECT_GROUP_BALLS"   );break;
492       default:           objType = tr( "OBJECT_GROUP"         );break;
493       }
494       myWidgets[iObject][iSingle]->setProperty( "text", objType );
495     }
496     SMESH::long_array_var info = obj->GetMeshInfo();
497     myWidgets[iNodes][iTotal] ->setProperty( "text", QString::number( info[SMDSEntity_Node] ) );
498     myWidgets[i0D][iTotal]    ->setProperty( "text", QString::number( info[SMDSEntity_0D] ) );
499     myWidgets[iBalls][iTotal] ->setProperty( "text", QString::number( info[SMDSEntity_Ball] ) );
500     long nbEdges = info[SMDSEntity_Edge] + info[SMDSEntity_Quad_Edge];
501     myWidgets[i1D][iTotal]    ->setProperty( "text", QString::number( nbEdges ) );
502     myWidgets[i1D][iLinear]   ->setProperty( "text", QString::number( info[SMDSEntity_Edge] ) );
503     myWidgets[i1D][iQuadratic]->setProperty( "text", QString::number( info[SMDSEntity_Quad_Edge] ) );
504     long nbTriangles     = info[SMDSEntity_Triangle]   + info[SMDSEntity_Quad_Triangle]   + info[SMDSEntity_BiQuad_Triangle];
505     long nbQuadrangles   = info[SMDSEntity_Quadrangle] + info[SMDSEntity_Quad_Quadrangle] + info[SMDSEntity_BiQuad_Quadrangle];
506     long nb2DLinear      = info[SMDSEntity_Triangle]        + info[SMDSEntity_Quadrangle] + info[SMDSEntity_Polygon];
507     long nb2DQuadratic   = info[SMDSEntity_Quad_Triangle]   + info[SMDSEntity_Quad_Quadrangle];
508     long nb2DBiQuadratic = info[SMDSEntity_BiQuad_Triangle] + info[SMDSEntity_BiQuad_Quadrangle];
509     long nb2DTotal       = nb2DLinear + nb2DQuadratic + nb2DBiQuadratic;
510
511     myWidgets[i2D][iTotal]                  ->setProperty( "text", QString::number( nb2DTotal ));
512     myWidgets[i2D][iLinear]                 ->setProperty( "text", QString::number( nb2DLinear ) );
513     myWidgets[i2D][iQuadratic]              ->setProperty( "text", QString::number( nb2DQuadratic ) );
514     myWidgets[i2D][iBiQuadratic]            ->setProperty( "text", QString::number( nb2DBiQuadratic ) );
515     myWidgets[i2DTriangles][iTotal]         ->setProperty( "text", QString::number( nbTriangles ) );
516     myWidgets[i2DTriangles][iLinear]        ->setProperty( "text", QString::number( info[SMDSEntity_Triangle] ) );
517     myWidgets[i2DTriangles][iQuadratic]     ->setProperty( "text", QString::number( info[SMDSEntity_Quad_Triangle] ) );
518     myWidgets[i2DTriangles][iBiQuadratic]   ->setProperty( "text", QString::number( info[SMDSEntity_BiQuad_Triangle] ) );
519     myWidgets[i2DQuadrangles][iTotal]       ->setProperty( "text", QString::number( nbQuadrangles ) );
520     myWidgets[i2DQuadrangles][iLinear]      ->setProperty( "text", QString::number( info[SMDSEntity_Quadrangle] ) );
521     myWidgets[i2DQuadrangles][iQuadratic]   ->setProperty( "text", QString::number( info[SMDSEntity_Quad_Quadrangle] ) );
522     myWidgets[i2DQuadrangles][iBiQuadratic] ->setProperty( "text", QString::number( info[SMDSEntity_BiQuad_Quadrangle] ) );
523     myWidgets[i2DPolygons][iTotal]          ->setProperty( "text", QString::number( info[SMDSEntity_Polygon] ) );
524     long nbTetrahedrons  = info[SMDSEntity_Tetra]   + info[SMDSEntity_Quad_Tetra];
525     long nbHexahedrons   = info[SMDSEntity_Hexa]    + info[SMDSEntity_Quad_Hexa] + info[SMDSEntity_TriQuad_Hexa];
526     long nbPyramids      = info[SMDSEntity_Pyramid] + info[SMDSEntity_Quad_Pyramid];
527     long nbPrisms        = info[SMDSEntity_Penta]   + info[SMDSEntity_Quad_Penta];
528     long nb3DLinear      = info[SMDSEntity_Tetra]   + info[SMDSEntity_Hexa] + info[SMDSEntity_Pyramid] + info[SMDSEntity_Penta] + info[SMDSEntity_Polyhedra] + info[SMDSEntity_Hexagonal_Prism];
529     long nb3DQuadratic   = info[SMDSEntity_Quad_Tetra] + info[SMDSEntity_Quad_Hexa] + info[SMDSEntity_Quad_Pyramid] + info[SMDSEntity_Quad_Penta];
530     long nb3DBiQuadratic = info[SMDSEntity_TriQuad_Hexa];
531     long nb3DTotal       = nb3DLinear + nb3DQuadratic + nb3DBiQuadratic;
532     myWidgets[i3D][iTotal]                  ->setProperty( "text", QString::number( nb3DTotal ) );
533     myWidgets[i3D][iLinear]                 ->setProperty( "text", QString::number( nb3DLinear ) );
534     myWidgets[i3D][iQuadratic]              ->setProperty( "text", QString::number( nb3DQuadratic ) );
535     myWidgets[i3D][iBiQuadratic]            ->setProperty( "text", QString::number( nb3DBiQuadratic ) );
536     myWidgets[i3DTetrahedrons][iTotal]      ->setProperty( "text", QString::number( nbTetrahedrons ) );
537     myWidgets[i3DTetrahedrons][iLinear]     ->setProperty( "text", QString::number( info[SMDSEntity_Tetra] ) );
538     myWidgets[i3DTetrahedrons][iQuadratic]  ->setProperty( "text", QString::number( info[SMDSEntity_Quad_Tetra] ) );
539     myWidgets[i3DHexahedrons][iTotal]       ->setProperty( "text", QString::number( nbHexahedrons ) );
540     myWidgets[i3DHexahedrons][iLinear]      ->setProperty( "text", QString::number( info[SMDSEntity_Hexa] ) );
541     myWidgets[i3DHexahedrons][iQuadratic]   ->setProperty( "text", QString::number( info[SMDSEntity_Quad_Hexa] ) );
542     myWidgets[i3DHexahedrons][iBiQuadratic] ->setProperty( "text", QString::number( info[SMDSEntity_TriQuad_Hexa] ) );
543     myWidgets[i3DPyramids][iTotal]          ->setProperty( "text", QString::number( nbPyramids ) );
544     myWidgets[i3DPyramids][iLinear]         ->setProperty( "text", QString::number( info[SMDSEntity_Pyramid] ) );
545     myWidgets[i3DPyramids][iQuadratic]      ->setProperty( "text", QString::number( info[SMDSEntity_Quad_Pyramid] ) );
546     myWidgets[i3DPrisms][iTotal]            ->setProperty( "text", QString::number( nbPrisms ) );
547     myWidgets[i3DPrisms][iLinear]           ->setProperty( "text", QString::number( info[SMDSEntity_Penta] ) );
548     myWidgets[i3DPrisms][iQuadratic]        ->setProperty( "text", QString::number( info[SMDSEntity_Quad_Penta] ) );
549     myWidgets[i3DHexaPrisms][iTotal]        ->setProperty( "text", QString::number( info[SMDSEntity_Hexagonal_Prism] ) );
550     myWidgets[i3DPolyhedrons][iTotal]       ->setProperty( "text", QString::number( info[SMDSEntity_Polyhedra] ) );
551     long nbElemTotal       = info[SMDSEntity_0D] + info[SMDSEntity_Ball] + nbEdges + nb2DTotal + nb3DTotal;
552     long nbElemLinerial    = info[SMDSEntity_Edge] + nb2DLinear + nb3DLinear;
553     long nbElemQuadratic   = info[SMDSEntity_Quad_Edge] + nb2DQuadratic + nb3DQuadratic;
554     long nbElemBiQuadratic = nb2DBiQuadratic + nb3DBiQuadratic;
555     myWidgets[iNb][iTotal]      ->setProperty( "text", QString::number( nbElemTotal ) );
556     myWidgets[iNb][iLinear]     ->setProperty( "text", QString::number( nbElemLinerial ) );
557     myWidgets[iNb][iQuadratic]  ->setProperty( "text", QString::number( nbElemQuadratic ) );
558     myWidgets[iNb][iBiQuadratic]->setProperty( "text", QString::number( nbElemBiQuadratic ) );
559     // before full loading from study file, type of elements in a sub-mesh can't be defined
560     // in some cases
561     bool infoOK = obj->IsMeshInfoCorrect();
562     myLoadBtn->setVisible( !infoOK );
563     if ( !infoOK )
564     {
565       // two options:
566       // 1. Type of 2D or 3D elements is unknown but their nb is OK (for a sub-mesh)
567       // 2. No info at all (for a group on geom or filter)
568       bool hasAnyInfo = false;
569       for ( size_t i = 0; i < info->length() && !hasAnyInfo; ++i )
570         hasAnyInfo = info[i];
571       if ( hasAnyInfo ) // believe it is a sub-mesh
572       {
573         if ( nb2DLinear + nb2DQuadratic + nb2DBiQuadratic > 0 )
574         {
575           myWidgets[i2D][iLinear]                 ->setProperty( "text", "?" );
576           myWidgets[i2D][iQuadratic]              ->setProperty( "text", "?" );
577           myWidgets[i2D][iBiQuadratic]            ->setProperty( "text", "?" );
578           myWidgets[i2DTriangles][iTotal]         ->setProperty( "text", "?" );
579           myWidgets[i2DTriangles][iLinear]        ->setProperty( "text", "?" );
580           myWidgets[i2DTriangles][iQuadratic]     ->setProperty( "text", "?" );
581           myWidgets[i2DTriangles][iBiQuadratic]   ->setProperty( "text", "?" );
582           myWidgets[i2DQuadrangles][iTotal]       ->setProperty( "text", "?" );
583           myWidgets[i2DQuadrangles][iLinear]      ->setProperty( "text", "?" );
584           myWidgets[i2DQuadrangles][iQuadratic]   ->setProperty( "text", "?" );
585           myWidgets[i2DQuadrangles][iBiQuadratic] ->setProperty( "text", "?" );
586           myWidgets[i2DPolygons][iTotal]          ->setProperty( "text", "?" );
587           myWidgets[iNb][iTotal]                  ->setProperty( "text", "?" );
588           myWidgets[iNb][iLinear]                 ->setProperty( "text", "?" );
589           myWidgets[iNb][iQuadratic]              ->setProperty( "text", "?" );
590           myWidgets[iNb][iBiQuadratic]            ->setProperty( "text", "?" );
591         }
592         else if ( nb3DLinear + nb3DQuadratic + nb3DBiQuadratic > 0 )
593         {
594           myWidgets[i3D][iLinear]                 ->setProperty( "text", "?" );
595           myWidgets[i3D][iQuadratic]              ->setProperty( "text", "?" );
596           myWidgets[i3D][iBiQuadratic]            ->setProperty( "text", "?" );
597           myWidgets[i3DTetrahedrons][iTotal]      ->setProperty( "text", "?" );
598           myWidgets[i3DTetrahedrons][iLinear]     ->setProperty( "text", "?" );
599           myWidgets[i3DTetrahedrons][iQuadratic]  ->setProperty( "text", "?" );
600           myWidgets[i3DHexahedrons][iTotal]       ->setProperty( "text", "?" );
601           myWidgets[i3DHexahedrons][iLinear]      ->setProperty( "text", "?" );
602           myWidgets[i3DHexahedrons][iQuadratic]   ->setProperty( "text", "?" );
603           myWidgets[i3DHexahedrons][iBiQuadratic] ->setProperty( "text", "?" );
604           myWidgets[i3DPyramids][iTotal]          ->setProperty( "text", "?" );
605           myWidgets[i3DPyramids][iLinear]         ->setProperty( "text", "?" );
606           myWidgets[i3DPyramids][iQuadratic]      ->setProperty( "text", "?" );
607           myWidgets[i3DPrisms][iTotal]            ->setProperty( "text", "?" );
608           myWidgets[i3DPrisms][iLinear]           ->setProperty( "text", "?" );
609           myWidgets[i3DPrisms][iQuadratic]        ->setProperty( "text", "?" );
610           myWidgets[i3DHexaPrisms][iTotal]        ->setProperty( "text", "?" );
611           myWidgets[i3DPolyhedrons][iTotal]       ->setProperty( "text", "?" );
612           myWidgets[iNb][iTotal]                  ->setProperty( "text", "?" );
613           myWidgets[iNb][iLinear]                 ->setProperty( "text", "?" );
614           myWidgets[iNb][iQuadratic]              ->setProperty( "text", "?" );
615           myWidgets[iNb][iBiQuadratic]            ->setProperty( "text", "?" );
616         }
617       }
618       else
619       {
620         myWidgets[iNodes][iTotal]               ->setProperty( "text", "?" );
621         myWidgets[i0D][iTotal]                  ->setProperty( "text", "?" );
622         myWidgets[iBalls][iTotal]               ->setProperty( "text", "?" );
623         myWidgets[i1D][iTotal]                  ->setProperty( "text", "?" );
624         myWidgets[i1D][iLinear]                 ->setProperty( "text", "?" );
625         myWidgets[i1D][iQuadratic]              ->setProperty( "text", "?" );
626         myWidgets[i2D][iTotal]                  ->setProperty( "text", "?" );
627         myWidgets[i2D][iLinear]                 ->setProperty( "text", "?" );
628         myWidgets[i2D][iQuadratic]              ->setProperty( "text", "?" );
629         myWidgets[i2D][iBiQuadratic]            ->setProperty( "text", "?" );
630         myWidgets[i2DTriangles][iTotal]         ->setProperty( "text", "?" );
631         myWidgets[i2DTriangles][iLinear]        ->setProperty( "text", "?" );
632         myWidgets[i2DTriangles][iQuadratic]     ->setProperty( "text", "?" );
633         myWidgets[i2DTriangles][iBiQuadratic]   ->setProperty( "text", "?" );
634         myWidgets[i2DQuadrangles][iTotal]       ->setProperty( "text", "?" );
635         myWidgets[i2DQuadrangles][iLinear]      ->setProperty( "text", "?" );
636         myWidgets[i2DQuadrangles][iQuadratic]   ->setProperty( "text", "?" );
637         myWidgets[i2DQuadrangles][iBiQuadratic] ->setProperty( "text", "?" );
638         myWidgets[i2DPolygons][iTotal]          ->setProperty( "text", "?" );
639         myWidgets[i3D][iTotal]                  ->setProperty( "text", "?" );
640         myWidgets[i3D][iLinear]                 ->setProperty( "text", "?" );
641         myWidgets[i3D][iQuadratic]              ->setProperty( "text", "?" );
642         myWidgets[i3DTetrahedrons][iTotal]      ->setProperty( "text", "?" );
643         myWidgets[i3DTetrahedrons][iLinear]     ->setProperty( "text", "?" );
644         myWidgets[i3DTetrahedrons][iQuadratic]  ->setProperty( "text", "?" );
645         myWidgets[i3DHexahedrons][iTotal]       ->setProperty( "text", "?" );
646         myWidgets[i3DHexahedrons][iLinear]      ->setProperty( "text", "?" );
647         myWidgets[i3DHexahedrons][iQuadratic]   ->setProperty( "text", "?" );
648         myWidgets[i3DHexahedrons][iBiQuadratic] ->setProperty( "text", "?" );
649         myWidgets[i3DPyramids][iTotal]          ->setProperty( "text", "?" );
650         myWidgets[i3DPyramids][iLinear]         ->setProperty( "text", "?" );
651         myWidgets[i3DPyramids][iQuadratic]      ->setProperty( "text", "?" );
652         myWidgets[i3DPrisms][iTotal]            ->setProperty( "text", "?" );
653         myWidgets[i3DPrisms][iLinear]           ->setProperty( "text", "?" );
654         myWidgets[i3DPrisms][iQuadratic]        ->setProperty( "text", "?" );
655         myWidgets[i3DHexaPrisms][iTotal]        ->setProperty( "text", "?" );
656         myWidgets[i3DPolyhedrons][iTotal]       ->setProperty( "text", "?" );
657         myWidgets[iNb][iTotal]                  ->setProperty( "text", "?" );
658         myWidgets[iNb][iLinear]                 ->setProperty( "text", "?" );
659         myWidgets[iNb][iQuadratic]              ->setProperty( "text", "?" );
660         myWidgets[iNb][iBiQuadratic]            ->setProperty( "text", "?" );
661       }
662     }
663   }
664 }
665
666 /*!
667   \brief Load mesh from a study file
668 */
669 void SMESHGUI_MeshInfo::loadMesh()
670 {
671   SUIT_OverrideCursor wc;
672
673   SALOME_ListIO selected;
674   SMESHGUI::selectionMgr()->selectedObjects( selected );
675
676   if ( selected.Extent() == 1 ) {
677     Handle(SALOME_InteractiveObject) IO = selected.First();
678     SMESH::SMESH_IDSource_var obj = SMESH::IObjectToInterface<SMESH::SMESH_IDSource>( IO );
679     if ( !CORBA::is_nil( obj ) ) {
680       SMESH::SMESH_Mesh_var mesh = obj->GetMesh();
681       if ( !mesh->_is_nil() )
682       {
683         mesh->Load();
684         showInfo( obj );
685       }
686     }
687   }
688 }
689
690 /*!
691   \brief Reset the widget to the initial state (nullify all fields).
692 */
693 void SMESHGUI_MeshInfo::clear()
694 {
695   myWidgets[iName][iSingle]               ->setProperty( "text", QString() );
696   myWidgets[iObject][iSingle]             ->setProperty( "text", QString() );
697   myWidgets[iNodes][iTotal]               ->setProperty( "text", QString::number( 0 ) );
698   myWidgets[i0D][iTotal]                  ->setProperty( "text", QString::number( 0 ) );
699   myWidgets[iBalls][iTotal]               ->setProperty( "text", QString::number( 0 ) );
700   myWidgets[i1D][iTotal]                  ->setProperty( "text", QString::number( 0 ) );
701   myWidgets[i1D][iLinear]                 ->setProperty( "text", QString::number( 0 ) );
702   myWidgets[i1D][iQuadratic]              ->setProperty( "text", QString::number( 0 ) );
703   myWidgets[i2D][iTotal]                  ->setProperty( "text", QString::number( 0 ) );
704   myWidgets[i2D][iLinear]                 ->setProperty( "text", QString::number( 0 ) );
705   myWidgets[i2D][iQuadratic]              ->setProperty( "text", QString::number( 0 ) );
706   myWidgets[i2D][iBiQuadratic]            ->setProperty( "text", QString::number( 0 ) );
707   myWidgets[i2DTriangles][iTotal]         ->setProperty( "text", QString::number( 0 ) );
708   myWidgets[i2DTriangles][iLinear]        ->setProperty( "text", QString::number( 0 ) );
709   myWidgets[i2DTriangles][iQuadratic]     ->setProperty( "text", QString::number( 0 ) );
710   myWidgets[i2DTriangles][iBiQuadratic]   ->setProperty( "text", QString::number( 0 ) );
711   myWidgets[i2DQuadrangles][iTotal]       ->setProperty( "text", QString::number( 0 ) );
712   myWidgets[i2DQuadrangles][iLinear]      ->setProperty( "text", QString::number( 0 ) );
713   myWidgets[i2DQuadrangles][iQuadratic]   ->setProperty( "text", QString::number( 0 ) );
714   myWidgets[i2DQuadrangles][iBiQuadratic] ->setProperty( "text", QString::number( 0 ) );
715   myWidgets[i2DPolygons][iTotal]          ->setProperty( "text", QString::number( 0 ) );
716   myWidgets[i3D][iTotal]                  ->setProperty( "text", QString::number( 0 ) );
717   myWidgets[i3D][iLinear]                 ->setProperty( "text", QString::number( 0 ) );
718   myWidgets[i3D][iQuadratic]              ->setProperty( "text", QString::number( 0 ) );
719   myWidgets[i3D][iBiQuadratic]            ->setProperty( "text", QString::number( 0 ) );
720   myWidgets[i3DTetrahedrons][iTotal]      ->setProperty( "text", QString::number( 0 ) );
721   myWidgets[i3DTetrahedrons][iLinear]     ->setProperty( "text", QString::number( 0 ) );
722   myWidgets[i3DTetrahedrons][iQuadratic]  ->setProperty( "text", QString::number( 0 ) );
723   myWidgets[i3DHexahedrons][iTotal]       ->setProperty( "text", QString::number( 0 ) );
724   myWidgets[i3DHexahedrons][iLinear]      ->setProperty( "text", QString::number( 0 ) );
725   myWidgets[i3DHexahedrons][iQuadratic]   ->setProperty( "text", QString::number( 0 ) );
726   myWidgets[i3DHexahedrons][iBiQuadratic] ->setProperty( "text", QString::number( 0 ) );
727   myWidgets[i3DPyramids][iTotal]          ->setProperty( "text", QString::number( 0 ) );
728   myWidgets[i3DPyramids][iLinear]         ->setProperty( "text", QString::number( 0 ) );
729   myWidgets[i3DPyramids][iQuadratic]      ->setProperty( "text", QString::number( 0 ) );
730   myWidgets[i3DPrisms][iTotal]            ->setProperty( "text", QString::number( 0 ) );
731   myWidgets[i3DPrisms][iLinear]           ->setProperty( "text", QString::number( 0 ) );
732   myWidgets[i3DPrisms][iQuadratic]        ->setProperty( "text", QString::number( 0 ) );
733   myWidgets[i3DHexaPrisms][iTotal]        ->setProperty( "text", QString::number( 0 ) );
734   myWidgets[i3DPolyhedrons][iTotal]       ->setProperty( "text", QString::number( 0 ) );
735   myWidgets[iNb][iTotal]                  ->setProperty( "text", QString::number( 0 ) );
736   myWidgets[iNb][iLinear]                 ->setProperty( "text", QString::number( 0 ) );
737   myWidgets[iNb][iQuadratic]              ->setProperty( "text", QString::number( 0 ) );
738   myWidgets[iNb][iBiQuadratic]            ->setProperty( "text", QString::number( 0 ) );
739 }
740
741 /*!
742   \brief Create info field
743   \return new info field
744 */
745 QLabel* SMESHGUI_MeshInfo::createField()
746 {
747   QLabel* lab = new QLabel( this );
748   lab->setFrameStyle( StyledPanel | Sunken );
749   lab->setAlignment( Qt::AlignCenter );
750   lab->setAutoFillBackground( true );
751   QPalette pal = lab->palette();
752   pal.setColor( QPalette::Window, QApplication::palette().color( QPalette::Active, QPalette::Base ) );
753   lab->setPalette( pal );
754   lab->setMinimumWidth( 70 );
755   return lab;
756 }
757
758 /*!
759   \brief Create horizontal rule.
760   \return new line object
761 */
762 QWidget* SMESHGUI_MeshInfo::createLine()
763 {
764   QFrame* line = new QFrame( this );
765   line->setFrameStyle( HLine | Sunken );
766   return line;
767 }
768
769 /*!
770   \brief Change widget font attributes (bold, italic, ...).
771   \param w widget
772   \param attr font attributes (XORed flags)
773   \param val value to be set to attributes
774 */
775 void SMESHGUI_MeshInfo::setFontAttributes( QWidget* w, int attr, bool val )
776 {
777   if ( w && attr ) {
778     QFont f = w->font();
779     if ( attr & Bold   ) f.setBold( val );
780     if ( attr & Italic ) f.setItalic( val );
781     w->setFont( f );
782   }
783 }
784
785 /*!
786   \brief Show/hide group(s) of fields.
787   \param start beginning of the block
788   \param end end of the block
789   \param on visibility flag
790 */
791 void SMESHGUI_MeshInfo::setFieldsVisible( int start, int end, bool on )
792 {
793   start = qMax( 0, start );
794   end   = qMin( end, (int)iElementsEnd );
795   for ( int i = start; i < end; i++ ) {
796     wlist wl = myWidgets[i];
797     foreach ( QWidget* w, wl ) w->setVisible( on );
798   }
799 }
800
801 void SMESHGUI_MeshInfo::saveInfo( QTextStream &out )
802 {
803   out << QString( 9, '-' ) << "\n";
804   out << tr( "BASE_INFO" ) << "\n";
805   out << QString( 9, '-' ) << "\n";
806   out <<                                   tr( "NAME_LAB" )         << "  " << ( myWidgets[iName][iSingle]->property( "text" ) ).toString() << "\n";
807   out <<                                   tr( "OBJECT_LAB" )       << "  " << ( myWidgets[iObject][iSingle]->property( "text" ) ).toString() << "\n";
808   out <<                                   tr( "NODES_LAB" )        << "  " << ( myWidgets[iNodes][iTotal]->property( "text" ) ).toString() << "\n";
809   out <<                                   tr( "ELEMENTS_LAB" )     << "\n";
810   out << QString( SPACING_INFO,   ' ' ) << tr( "TOTAL_LAB" )        << ": " << ( myWidgets[iNb][iTotal]->property( "text" ) ).toString() << "\n";
811   out << QString( SPACING_INFO,   ' ' ) << tr( "LINEAR_LAB" )       << ": " << ( myWidgets[iNb][iLinear]->property( "text" ) ).toString() << "\n";
812   out << QString( SPACING_INFO,   ' ' ) << tr( "QUADRATIC_LAB" )    << ": " << ( myWidgets[iNb][iQuadratic]->property( "text" ) ).toString() << "\n";
813   out << QString( SPACING_INFO,   ' ' ) << tr( "BI_QUADRATIC_LAB" ) << ": " << ( myWidgets[iNb][iBiQuadratic]->property( "text" ) ).toString() << "\n";
814   out << QString( SPACING_INFO,   ' ' ) << tr( "0D_LAB" )           << "\n";
815   out << QString( SPACING_INFO*2, ' ' ) << tr( "TOTAL_LAB" )        << ": " << ( myWidgets[i0D][iTotal]->property( "text" ) ).toString() << "\n";
816   out << QString( SPACING_INFO,   ' ' ) << tr( "BALL_LAB" )         << "\n";
817   out << QString( SPACING_INFO*2, ' ' ) << tr( "TOTAL_LAB" )        << ": " << ( myWidgets[iBalls][iTotal]->property( "text" ) ).toString() << "\n";
818   out << QString( SPACING_INFO,   ' ' ) << tr( "1D_LAB" )           << "\n";
819   out << QString( SPACING_INFO*2, ' ' ) << tr( "TOTAL_LAB" )        << ": " << ( myWidgets[i1D][iTotal]->property( "text" ) ).toString() << "\n";
820   out << QString( SPACING_INFO*2, ' ' ) << tr( "LINEAR_LAB" )       << ": " << ( myWidgets[i1D][iLinear]->property( "text" ) ).toString() << "\n";
821   out << QString( SPACING_INFO*2, ' ' ) << tr( "QUADRATIC_LAB" )    << ": " << ( myWidgets[i1D][iQuadratic]->property( "text" ) ).toString() << "\n";
822   out << QString( SPACING_INFO,   ' ' ) << tr( "2D_LAB" )           << "\n";
823   out << QString( SPACING_INFO*2, ' ' ) << tr( "TOTAL_LAB" )        << ": " << ( myWidgets[i2D][iTotal]->property( "text" ) ).toString() << "\n";
824   out << QString( SPACING_INFO*2, ' ' ) << tr( "LINEAR_LAB" )       << ": " << ( myWidgets[i2D][iLinear]->property( "text" ) ).toString() << "\n";
825   out << QString( SPACING_INFO*2, ' ' ) << tr( "QUADRATIC_LAB" )    << ": " << ( myWidgets[i2D][iQuadratic]->property( "text" ) ).toString() << "\n";
826   out << QString( SPACING_INFO*2, ' ' ) << tr( "BI_QUADRATIC_LAB" ) << ": " << ( myWidgets[i2D][iBiQuadratic]->property( "text" ) ).toString() << "\n";
827   out << QString( SPACING_INFO*2, ' ' ) << tr( "TRIANGLES_LAB" )    << "\n";
828   out << QString( SPACING_INFO*3, ' ' ) << tr( "TOTAL_LAB" )        << ": " << ( myWidgets[i2DTriangles][iTotal]->property( "text" ) ).toString() << "\n";
829   out << QString( SPACING_INFO*3, ' ' ) << tr( "LINEAR_LAB" )       << ": " << ( myWidgets[i2DTriangles][iLinear]->property( "text" ) ).toString() << "\n";
830   out << QString( SPACING_INFO*3, ' ' ) << tr( "QUADRATIC_LAB" )    << ": " << ( myWidgets[i2DTriangles][iQuadratic]->property( "text" ) ).toString() << "\n";
831   out << QString( SPACING_INFO*3, ' ' ) << tr( "BI_QUADRATIC_LAB" ) << ": " << ( myWidgets[i2DTriangles][iBiQuadratic]->property( "text" ) ).toString() << "\n";
832   out << QString( SPACING_INFO*2, ' ' ) << tr( "QUADRANGLES_LAB" )  << "\n";
833   out << QString( SPACING_INFO*3, ' ' ) << tr( "TOTAL_LAB" )        << ": " << ( myWidgets[i2DQuadrangles][iTotal]->property( "text" ) ).toString() << "\n";
834   out << QString( SPACING_INFO*3, ' ' ) << tr( "LINEAR_LAB" )       << ": " << ( myWidgets[i2DQuadrangles][iLinear]->property( "text" ) ).toString() << "\n";
835   out << QString( SPACING_INFO*3, ' ' ) << tr( "QUADRATIC_LAB" )    << ": " << ( myWidgets[i2DQuadrangles][iQuadratic]->property( "text" ) ).toString() << "\n";
836   out << QString( SPACING_INFO*3, ' ' ) << tr( "BI_QUADRATIC_LAB" ) << ": " << ( myWidgets[i2DQuadrangles][iBiQuadratic]->property( "text" ) ).toString() << "\n";
837   out << QString( SPACING_INFO*2, ' ' ) << tr( "POLYGONS_LAB" )     << "\n";
838   out << QString( SPACING_INFO*3, ' ' ) << tr( "TOTAL_LAB" )        << ": " << ( myWidgets[i2DPolygons][iTotal]->property( "text" ) ).toString() << "\n";
839   out << QString( SPACING_INFO,   ' ' ) << tr( "3D_LAB" )           << "\n";
840   out << QString( SPACING_INFO*2, ' ' ) << tr( "TOTAL_LAB" )        << ": " << ( myWidgets[i3D][iTotal]->property( "text" ) ).toString() << "\n";
841   out << QString( SPACING_INFO*2, ' ' ) << tr( "LINEAR_LAB" )       << ": " << ( myWidgets[i3D][iLinear]->property( "text" ) ).toString() << "\n";
842   out << QString( SPACING_INFO*2, ' ' ) << tr( "QUADRATIC_LAB" )    << ": " << ( myWidgets[i3D][iQuadratic]->property( "text" ) ).toString() << "\n";
843   out << QString( SPACING_INFO*2, ' ' ) << tr( "BI_QUADRATIC_LAB" ) << ": " << ( myWidgets[i3D][iBiQuadratic]->property( "text" ) ).toString() << "\n";
844   out << QString( SPACING_INFO*2, ' ' ) << tr( "TETRAHEDRONS_LAB" ) << "\n";
845   out << QString( SPACING_INFO*3, ' ' ) << tr( "TOTAL_LAB" )        << ": " << ( myWidgets[i3DTetrahedrons][iTotal]->property( "text" ) ).toString() << "\n";
846   out << QString( SPACING_INFO*3, ' ' ) << tr( "LINEAR_LAB" )       << ": " << ( myWidgets[i3DTetrahedrons][iLinear]->property( "text" ) ).toString() << "\n";
847   out << QString( SPACING_INFO*3, ' ' ) << tr( "QUADRATIC_LAB" )    << ": " << ( myWidgets[i3DTetrahedrons][iQuadratic]->property( "text" ) ).toString() << "\n";
848   out << QString( SPACING_INFO*2, ' ' ) << tr( "HEXAHEDONRS_LAB" )  << "\n";
849   out << QString( SPACING_INFO*3, ' ' ) << tr( "TOTAL_LAB" )        << ": " << ( myWidgets[i3DHexahedrons][iTotal]->property( "text" ) ).toString() << "\n";
850   out << QString( SPACING_INFO*3, ' ' ) << tr( "LINEAR_LAB" )       << ": " << ( myWidgets[i3DHexahedrons][iLinear]->property( "text" ) ).toString() << "\n";
851   out << QString( SPACING_INFO*3, ' ' ) << tr( "QUADRATIC_LAB" )    << ": " << ( myWidgets[i3DHexahedrons][iQuadratic]->property( "text" ) ).toString() << "\n";
852   out << QString( SPACING_INFO*3, ' ' ) << tr( "BI_QUADRATIC_LAB" ) << ": " << ( myWidgets[i3DHexahedrons][iBiQuadratic]->property( "text" ) ).toString() << "\n";
853   out << QString( SPACING_INFO*2, ' ' ) << tr( "PYRAMIDS_LAB" )     << "\n";
854   out << QString( SPACING_INFO*3, ' ' ) << tr( "TOTAL_LAB" )        << ": " << ( myWidgets[i3DPyramids][iTotal]->property( "text" ) ).toString() << "\n";
855   out << QString( SPACING_INFO*3, ' ' ) << tr( "LINEAR_LAB" )       << ": " << ( myWidgets[i3DPyramids][iLinear]->property( "text" ) ).toString() << "\n";
856   out << QString( SPACING_INFO*3, ' ' ) << tr( "QUADRATIC_LAB" )    << ": " << ( myWidgets[i3DPyramids][iQuadratic]->property( "text" ) ).toString() << "\n";
857   out << QString( SPACING_INFO*2, ' ' ) << tr( "PRISMS_LAB" )       << "\n";
858   out << QString( SPACING_INFO*3, ' ' ) << tr( "TOTAL_LAB" )        << ": " << ( myWidgets[i3DPrisms][iTotal]->property( "text" ) ).toString() << "\n";
859   out << QString( SPACING_INFO*3, ' ' ) << tr( "LINEAR_LAB" )       << ": " << ( myWidgets[i3DPrisms][iLinear]->property( "text" ) ).toString() << "\n";
860   out << QString( SPACING_INFO*3, ' ' ) << tr( "QUADRATIC_LAB" )    << ": " << ( myWidgets[i3DPrisms][iQuadratic]->property( "text" ) ).toString() << "\n";
861   out << QString( SPACING_INFO*2, ' ' ) << tr( "HEX_PRISMS_LAB" )   << "\n";
862   out << QString( SPACING_INFO*3, ' ' ) << tr( "TOTAL_LAB" )        << ": " << ( myWidgets[i3DHexaPrisms][iTotal]->property( "text" ) ).toString() << "\n";
863   out << QString( SPACING_INFO*2, ' ' ) << tr( "POLYHEDRONS_LAB" )  << "\n";
864   out << QString( SPACING_INFO*3, ' ' ) << tr( "TOTAL_LAB" )        << ": " << ( myWidgets[i3DPolyhedrons][iTotal]->property( "text" ) ).toString() << "\n" << "\n";
865 }
866
867 /*!
868   \class SMESHGUI_ElemInfo
869   \brief Base class for the mesh element information widget.
870 */
871
872 /*!
873   \brief Constructor
874   \param parent parent widget
875 */
876 SMESHGUI_ElemInfo::SMESHGUI_ElemInfo( QWidget* parent )
877 : QWidget( parent ), myActor( 0 ), myIsElement( -1 )
878 {
879   myFrame = new QWidget( this );
880   myExtra = new ExtraWidget( this );
881   QVBoxLayout* vbl = new QVBoxLayout( this );
882   vbl->setMargin( 0 );
883   vbl->setSpacing( 0 );
884   vbl->addWidget( myFrame );
885   vbl->addWidget( myExtra );
886   connect( myExtra->prev, SIGNAL( clicked() ), this, SLOT( showPrevious() ) );
887   connect( myExtra->next, SIGNAL( clicked() ), this, SLOT( showNext() ) );
888   clear();
889 }
890
891 /*!
892   \brief Destructor
893 */
894 SMESHGUI_ElemInfo::~SMESHGUI_ElemInfo()
895 {
896 }
897
898 /*!
899   \brief Set mesh data source (actor)
900   \param actor mesh object actor
901 */
902 void SMESHGUI_ElemInfo::setSource( SMESH_Actor* actor )
903 {
904   if ( myActor != actor ) {
905     myActor = actor;
906     myIsElement = -1;
907     clear();
908   }
909 }
910
911 /*!
912   \brief Show mesh element information
913   \param id mesh node / element ID
914   \param isElem show mesh element information if \c true or mesh node information if \c false
915 */
916 void SMESHGUI_ElemInfo::showInfo( long id, bool isElem )
917 {
918   QSet<long> ids;
919   ids << id;
920   showInfo( ids, isElem );
921 }
922
923 /*!
924   \brief Show mesh element information
925   \param ids mesh nodes / elements identifiers
926   \param isElem show mesh element information if \c true or mesh node information if \c false
927 */
928 void SMESHGUI_ElemInfo::showInfo( QSet<long> ids, bool isElem )
929 {
930   QList<long> newIds = ids.toList();
931   qSort( newIds );
932   if ( myIDs == newIds && myIsElement == isElem ) return;
933
934   myIDs = newIds;
935   myIsElement = isElem;
936   myIndex = 0;
937   updateControls();
938   information( myIDs.mid( myIndex*MAXITEMS, MAXITEMS ) );
939 }
940
941 /*!
942   \brief Clear mesh element information widget
943 */
944 void SMESHGUI_ElemInfo::clear()
945 {
946   myIDs.clear();
947   myIndex = 0;
948   clearInternal();
949   updateControls();
950 }
951
952 /*!
953   \brief Get central area widget
954   \return central widget
955 */
956 QWidget* SMESHGUI_ElemInfo::frame() const
957 {
958   return myFrame;
959 }
960
961 /*!
962   \brief Get actor
963   \return actor being used
964 */
965 SMESH_Actor* SMESHGUI_ElemInfo::actor() const
966 {
967   return myActor;
968 }
969
970 /*!
971   \brief Get current info mode.
972   \return \c true if mesh element information is shown or \c false if node information is shown
973 */
974 bool SMESHGUI_ElemInfo::isElements() const
975 {
976   return myIsElement;
977 }
978
979 /*!
980   \fn void SMESHGUI_ElemInfo::information( const QList<long>& ids )
981   \brief Show information on the specified nodes / elements
982
983   This function is to be redefined in sub-classes.
984
985   \param ids nodes / elements identifiers information is to be shown on
986 */
987
988 /*!
989   \brief Internal clean-up (reset widget)
990 */
991 void SMESHGUI_ElemInfo::clearInternal()
992 {
993 }
994
995 /*!
996   \brief Get node connectivity
997   \param node mesh node
998   \return node connectivity map
999 */
1000 SMESHGUI_ElemInfo::Connectivity SMESHGUI_ElemInfo::nodeConnectivity( const SMDS_MeshNode* node )
1001 {
1002   Connectivity elmap;
1003   if ( node ) {
1004     SMDS_ElemIteratorPtr it = node->GetInverseElementIterator();
1005     while ( it && it->more() ) {
1006       const SMDS_MeshElement* ne = it->next();
1007       elmap[ ne->GetType() ] << ne->GetID();
1008     }
1009   }
1010   return elmap;
1011 }
1012
1013 /*!
1014   \brief Format connectivity data to string representation
1015   \param connectivity connetivity map
1016   \param type element type
1017   \return string representation of the connectivity
1018 */
1019 QString SMESHGUI_ElemInfo::formatConnectivity( Connectivity connectivity, int type )
1020 {
1021   QStringList str;
1022   if ( connectivity.contains( type ) ) {
1023     QList<int> elements = connectivity[ type ];
1024     qSort( elements );
1025     foreach( int id, elements )
1026       str << QString::number( id );
1027   }
1028   return str.join( " " );
1029 }
1030
1031 /*!
1032   \brief Calculate gravity center of the mesh element
1033   \param element mesh element
1034 */
1035 SMESHGUI_ElemInfo::XYZ SMESHGUI_ElemInfo::gravityCenter( const SMDS_MeshElement* element )
1036 {
1037   XYZ xyz;
1038   if ( element ) {
1039     SMDS_ElemIteratorPtr nodeIt = element->nodesIterator();
1040     while ( nodeIt->more() ) {
1041       const SMDS_MeshNode* node = static_cast<const SMDS_MeshNode*>( nodeIt->next() );
1042       xyz.add( node->X(), node->Y(), node->Z() );
1043     }
1044     xyz.divide( element->NbNodes() );
1045   }
1046   return xyz;
1047 }
1048
1049 /*!
1050   \brief Calculate normal vector to the mesh face
1051   \param element mesh face
1052 */
1053 SMESHGUI_ElemInfo::XYZ SMESHGUI_ElemInfo::normal( const SMDS_MeshElement* element )
1054 {
1055   gp_XYZ n = SMESH::getNormale( dynamic_cast<const SMDS_MeshFace*>( element ) );
1056   return XYZ(n.X(), n.Y(), n.Z());
1057 }
1058
1059 /*!
1060   \brief This slot is called from "Show Previous" button click.
1061   Shows information on the previous group of the items.
1062 */
1063 void SMESHGUI_ElemInfo::showPrevious()
1064 {
1065   myIndex = qMax( 0, myIndex-1 );
1066   updateControls();
1067   information( myIDs.mid( myIndex*MAXITEMS, MAXITEMS ) );
1068 }
1069
1070 /*!
1071   \brief This slot is called from "Show Next" button click.
1072   Shows information on the next group of the items.
1073 */
1074 void SMESHGUI_ElemInfo::showNext()
1075 {
1076   myIndex = qMin( myIndex+1, myIDs.count() / MAXITEMS );
1077   updateControls();
1078   information( myIDs.mid( myIndex*MAXITEMS, MAXITEMS ) );
1079 }
1080
1081 /*!
1082   \brief Update widgets state
1083 */
1084 void SMESHGUI_ElemInfo::updateControls()
1085 {
1086   myExtra->updateControls( myIDs.count(), myIndex );
1087 }
1088
1089 /*!
1090   \class SMESHGUI_SimpleElemInfo
1091   \brief Represents mesh element information in the simple text area.
1092 */
1093
1094 /*!
1095   \brief Constructor
1096   \param parent parent widget
1097 */
1098 SMESHGUI_SimpleElemInfo::SMESHGUI_SimpleElemInfo( QWidget* parent )
1099 : SMESHGUI_ElemInfo( parent )
1100 {
1101   myInfo = new QTextBrowser( frame() );
1102   QVBoxLayout* l = new QVBoxLayout( frame() );
1103   l->setMargin( 0 );
1104   l->addWidget( myInfo );
1105 }
1106
1107 /*!
1108   \brief Show mesh element information
1109   \param ids mesh nodes / elements identifiers
1110 */
1111 void SMESHGUI_SimpleElemInfo::information( const QList<long>& ids )
1112 {
1113   clearInternal();
1114   
1115   if ( actor() ) {
1116     int grp_details = SMESHGUI::resourceMgr()->booleanValue( "SMESH", "elem_info_grp_details", false );
1117     int precision   = SMESHGUI::resourceMgr()->integerValue( "SMESH", "length_precision", 6 );
1118     int cprecision = -1;
1119     if ( SMESHGUI::resourceMgr()->booleanValue( "SMESH", "use_precision", false ) ) 
1120       cprecision = SMESHGUI::resourceMgr()->integerValue( "SMESH", "controls_precision", -1 );
1121     foreach ( long id, ids ) {
1122       if ( !isElements() ) {
1123         //
1124         // show node info
1125         //
1126         const SMDS_MeshNode* node = actor()->GetObject()->GetMesh()->FindNode( id );
1127         if ( !node ) return;
1128
1129         // node ID
1130         myInfo->append( QString( "<b>%1 #%2</b>" ).arg( SMESHGUI_ElemInfo::tr( "NODE" ) ).arg( id ) );
1131         // separator
1132         myInfo->append( "" );
1133         // coordinates
1134         myInfo->append( QString( "<b>%1:</b> (%2, %3, %4)" ).arg( SMESHGUI_ElemInfo::tr( "COORDINATES" ) ).
1135                         arg( node->X(), 0, precision > 0 ? 'f' : 'g', qAbs( precision ) ).
1136                         arg( node->Y(), 0, precision > 0 ? 'f' : 'g', qAbs( precision ) ).
1137                         arg( node->Z(), 0, precision > 0 ? 'f' : 'g', qAbs( precision ) ) );
1138         // separator
1139         myInfo->append( "" );
1140         // connectivity
1141         Connectivity connectivity = nodeConnectivity( node );
1142         if ( !connectivity.isEmpty() ) {
1143           myInfo->append( QString( "<b>%1:</b>" ).arg( SMESHGUI_ElemInfo::tr( "CONNECTIVITY" ) ) );
1144           QString con = formatConnectivity( connectivity, SMDSAbs_0DElement );
1145           if ( !con.isEmpty() )
1146             myInfo->append( QString( "- <b>%1:</b> %2" ).arg( SMESHGUI_ElemInfo::tr( "0D_ELEMENTS" ) ).arg( con ) );
1147           con = formatConnectivity( connectivity, SMDSAbs_Edge );
1148           if ( !con.isEmpty() )
1149             myInfo->append( QString( "- <b>%1:</b> %2" ).arg( SMESHGUI_ElemInfo::tr( "EDGES" ) ).arg( con ) );
1150           con = formatConnectivity( connectivity, SMDSAbs_Ball );
1151           if ( !con.isEmpty() )
1152             myInfo->append( QString( "- <b>%1:</b> %2" ).arg( SMESHGUI_ElemInfo::tr( "BALL_ELEMENTS" ) ).arg( con ) );
1153           con = formatConnectivity( connectivity, SMDSAbs_Face );
1154           if ( !con.isEmpty() )
1155             myInfo->append( QString( "- <b>%1:</b> %2" ).arg( SMESHGUI_ElemInfo::tr( "FACES" ) ).arg( con ) );
1156           con = formatConnectivity( connectivity, SMDSAbs_Volume );
1157           if ( !con.isEmpty() )
1158             myInfo->append( QString( "- <b>%1:</b> %2" ).arg( SMESHGUI_ElemInfo::tr( "VOLUMES" ) ).arg( con ) );
1159         }
1160         else {
1161           myInfo->append( QString( "<b>%1</b>" ).arg( SMESHGUI_ElemInfo::tr( "FREE_NODE" ) ).arg( id ) );
1162         }
1163         // node position
1164         SMESH::SMESH_Mesh_ptr aMeshPtr = actor()->GetObject()->GetMeshServer();   
1165         if ( !CORBA::is_nil( aMeshPtr ) ) {
1166           SMESH::NodePosition_var pos = aMeshPtr->GetNodePosition( id );
1167           int shapeID = pos->shapeID;
1168           if ( shapeID > 0 ) {
1169             QString shapeType;
1170             double u, v;
1171             switch ( pos->shapeType ) {
1172             case GEOM::EDGE:
1173               shapeType = SMESHGUI_ElemInfo::tr( "GEOM_EDGE" );
1174               if ( pos->params.length() == 1 )
1175                 u = pos->params[0];
1176               break;
1177             case GEOM::FACE:
1178               shapeType = SMESHGUI_ElemInfo::tr( "GEOM_FACE" );
1179               if ( pos->params.length() == 2 ) {
1180                u = pos->params[0];
1181                v = pos->params[1];
1182               }
1183               break;
1184             case GEOM::VERTEX:
1185               shapeType = SMESHGUI_ElemInfo::tr( "GEOM_VERTEX" );
1186               break;
1187             default:
1188               shapeType = SMESHGUI_ElemInfo::tr( "GEOM_SOLID" );
1189               break;
1190             }
1191             // separator
1192             myInfo->append( "" );
1193             myInfo->append( QString( "<b>%1:" ).arg( SMESHGUI_ElemInfo::tr( "POSITION" ) ) );
1194             myInfo->append( QString( "- <b>%1: #%2</b>" ).arg( shapeType ).arg( shapeID ) );
1195             if ( pos->shapeType == GEOM::EDGE || pos->shapeType == GEOM::FACE ) {
1196               myInfo->append( QString( "- <b>%1: #%2</b>" ).arg( SMESHGUI_ElemInfo::tr( "U_POSITION" ) ).
1197                               arg( QString::number( u, precision > 0 ? 'f' : 'g', qAbs( precision )) ) );
1198               if ( pos->shapeType == GEOM::FACE ) {
1199                 myInfo->append( QString( "- <b>%1: #%2</b>" ).arg( SMESHGUI_ElemInfo::tr( "V_POSITION" ) ).
1200                                 arg( QString::number( v, precision > 0 ? 'f' : 'g', qAbs( precision )) ) );
1201               }
1202             }
1203           }
1204         }
1205         // groups node belongs to
1206         SMESH::SMESH_Mesh_ptr aMesh = actor()->GetObject()->GetMeshServer();
1207         if ( !CORBA::is_nil( aMesh ) ) {
1208           SMESH::ListOfGroups_var groups = aMesh->GetGroups();
1209           myInfo->append( "" ); // separator
1210           bool top_created = false;
1211           for ( int i = 0; i < groups->length(); i++ ) {
1212             SMESH::SMESH_GroupBase_var aGrp = groups[i];
1213             if ( CORBA::is_nil( aGrp ) ) continue;
1214             QString aName = aGrp->GetName();
1215             if ( aGrp->GetType() == SMESH::NODE && !aName.isEmpty() && aGrp->Contains( id ) ) {
1216               if ( !top_created ) {
1217                 myInfo->append( QString( "<b>%1:</b>" ).arg( SMESHGUI_AddInfo::tr( "GROUPS" ) ) );
1218                 top_created = true;
1219               }
1220               myInfo->append( QString( "+ <b>%1:</b>" ).arg( aName.trimmed() ) );
1221               if ( grp_details ) {
1222                 SMESH::SMESH_Group_var         aStdGroup  = SMESH::SMESH_Group::_narrow( aGrp );
1223                 SMESH::SMESH_GroupOnGeom_var   aGeomGroup = SMESH::SMESH_GroupOnGeom::_narrow( aGrp );
1224                 SMESH::SMESH_GroupOnFilter_var aFltGroup  = SMESH::SMESH_GroupOnFilter::_narrow( aGrp );
1225                 
1226                 // type : group on geometry, standalone group, group on filter
1227                 if ( !CORBA::is_nil( aStdGroup ) ) {
1228                   myInfo->append( QString( "  - <b>%1:</b> %2" ).arg( SMESHGUI_AddInfo::tr( "TYPE" ) ).
1229                                   arg( SMESHGUI_AddInfo::tr( "STANDALONE_GROUP" ) ) );
1230                 }
1231                 else if ( !CORBA::is_nil( aGeomGroup ) ) {
1232                   myInfo->append( QString( "  - <b>%1:</b> %2" ).arg( SMESHGUI_AddInfo::tr( "TYPE" ) ).
1233                                   arg( SMESHGUI_AddInfo::tr( "GROUP_ON_GEOMETRY" ) ) );
1234                   GEOM::GEOM_Object_var gobj = aGeomGroup->GetShape();
1235                   _PTR(SObject) sobj = SMESH::ObjectToSObject( gobj );
1236                   if ( sobj ) {
1237                     myInfo->append( QString( "  - <b>%1:</b> %2: %3" ).arg( SMESHGUI_AddInfo::tr( "TYPE" ) ).
1238                                     arg( SMESHGUI_AddInfo::tr( "GEOM_OBJECT" ) ).arg( sobj->GetName().c_str() ) );
1239                   }
1240                 }
1241                 else if ( !CORBA::is_nil( aFltGroup ) ) {
1242                   myInfo->append( QString( "  - <b>%1:</b> %2" ).arg( SMESHGUI_AddInfo::tr( "TYPE" ) ).
1243                                   arg( SMESHGUI_AddInfo::tr( "GROUP_ON_FILTER" ) ) );
1244                 }
1245                 
1246                 // size
1247                 myInfo->append( QString( "  - <b>%1:</b> %2" ).arg( SMESHGUI_AddInfo::tr( "SIZE" ) ).
1248                                 arg( QString::number( aGrp->Size() ) ) );
1249                 
1250                 // color
1251                 SALOMEDS::Color color = aGrp->GetColor();
1252                 myInfo->append( QString( "  - <b>%1:</b> %2" ).arg( SMESHGUI_AddInfo::tr( "COLOR" ) ).
1253                                 arg( QColor( color.R*255., color.G*255., color.B*255. ).name() ) );
1254               }
1255             }
1256           }
1257         }
1258       }
1259       else {
1260         //
1261         // show element info
1262         // 
1263         const SMDS_MeshElement* e = actor()->GetObject()->GetMesh()->FindElement( id );
1264         SMESH::Controls::NumericalFunctorPtr afunctor;
1265         if ( !e ) return;
1266         
1267         // Element ID && Type
1268         QString stype;
1269         switch( e->GetType() ) {
1270         case SMDSAbs_0DElement:
1271           stype = SMESHGUI_ElemInfo::tr( "0D_ELEMENT" ); break;
1272         case SMDSAbs_Ball:
1273           stype = SMESHGUI_ElemInfo::tr( "BALL" ); break;
1274         case SMDSAbs_Edge:
1275           stype = SMESHGUI_ElemInfo::tr( "EDGE" ); break;
1276         case SMDSAbs_Face:
1277           stype = SMESHGUI_ElemInfo::tr( "FACE" ); break;
1278         case SMDSAbs_Volume:
1279           stype = SMESHGUI_ElemInfo::tr( "VOLUME" ); break;
1280         default: 
1281           break;
1282         }
1283         if ( stype.isEmpty() ) return;
1284         myInfo->append( QString( "<b>%1 #%2</b>" ).arg( stype ).arg( id ) );
1285         // separator
1286         myInfo->append( "" );
1287
1288         // Geometry type
1289         QString gtype;
1290         switch( e->GetEntityType() ) {
1291         case SMDSEntity_Triangle:
1292         case SMDSEntity_Quad_Triangle:
1293         case SMDSEntity_BiQuad_Triangle:
1294           gtype = SMESHGUI_ElemInfo::tr( "TRIANGLE" ); break;
1295         case SMDSEntity_Quadrangle:
1296         case SMDSEntity_Quad_Quadrangle:
1297         case SMDSEntity_BiQuad_Quadrangle:
1298           gtype = SMESHGUI_ElemInfo::tr( "QUADRANGLE" ); break;
1299         case SMDSEntity_Polygon:
1300         case SMDSEntity_Quad_Polygon:
1301           gtype = SMESHGUI_ElemInfo::tr( "POLYGON" ); break;
1302         case SMDSEntity_Tetra:
1303         case SMDSEntity_Quad_Tetra:
1304           gtype = SMESHGUI_ElemInfo::tr( "TETRAHEDRON" ); break;
1305         case SMDSEntity_Pyramid:
1306         case SMDSEntity_Quad_Pyramid:
1307           gtype = SMESHGUI_ElemInfo::tr( "PYRAMID" ); break;
1308         case SMDSEntity_Hexa:
1309         case SMDSEntity_Quad_Hexa:
1310         case SMDSEntity_TriQuad_Hexa:
1311           gtype = SMESHGUI_ElemInfo::tr( "HEXAHEDRON" ); break;
1312         case SMDSEntity_Penta:
1313         case SMDSEntity_Quad_Penta:
1314           gtype = SMESHGUI_ElemInfo::tr( "PRISM" ); break;
1315         case SMDSEntity_Hexagonal_Prism:
1316           gtype = SMESHGUI_ElemInfo::tr( "HEX_PRISM" ); break;
1317         case SMDSEntity_Polyhedra:
1318         case SMDSEntity_Quad_Polyhedra:
1319           gtype = SMESHGUI_ElemInfo::tr( "POLYHEDRON" ); break;
1320         default: 
1321           break;
1322         }
1323         if ( !gtype.isEmpty() )
1324           myInfo->append( QString( "<b>%1:</b> %2" ).arg( SMESHGUI_ElemInfo::tr( "TYPE" ) ).arg( gtype ) );
1325
1326         // Quadratic flag (any element except 0D)
1327         if ( e->GetEntityType() > SMDSEntity_0D && e->GetEntityType() < SMDSEntity_Ball ) {
1328           myInfo->append( QString( "<b>%1?</b> %2" ).arg( SMESHGUI_ElemInfo::tr( "QUADRATIC" ) ).arg( e->IsQuadratic() ? SMESHGUI_ElemInfo::tr( "YES" ) : SMESHGUI_ElemInfo::tr( "NO" ) ) );
1329         }
1330         if ( const SMDS_BallElement* ball = dynamic_cast<const SMDS_BallElement*>( e )) {
1331           // Ball diameter
1332           myInfo->append( QString( "<b>%1:</b> %2" ).arg( SMESHGUI_ElemInfo::tr( "BALL_DIAMETER" ) ).arg( ball->GetDiameter() ));
1333         }
1334         // separator
1335         myInfo->append( "" );
1336
1337         // Connectivity
1338         SMDS_ElemIteratorPtr nodeIt = e->nodesIterator();
1339         for ( int idx = 1; nodeIt->more(); idx++ ) {
1340           const SMDS_MeshNode* node = static_cast<const SMDS_MeshNode*>( nodeIt->next() );
1341           // node number and ID
1342           myInfo->append( QString( "<b>%1 %2/%3</b> - #%4" ).arg( SMESHGUI_ElemInfo::tr( "NODE" ) ).arg( idx ).arg( e->NbNodes() ).arg( node->GetID() ) );
1343           // node coordinates
1344           myInfo->append( QString( "<b>%1:</b> (%2, %3, %4)" ).arg( SMESHGUI_ElemInfo::tr( "COORDINATES" ) ).
1345                           arg( node->X(), 0, precision > 0 ? 'f' : 'g', qAbs( precision ) ).
1346                           arg( node->Y(), 0, precision > 0 ? 'f' : 'g', qAbs( precision ) ).
1347                           arg( node->Z(), 0, precision > 0 ? 'f' : 'g', qAbs( precision ) ) );
1348           // node connectivity
1349           Connectivity connectivity = nodeConnectivity( node );
1350           if ( !connectivity.isEmpty() ) {
1351             myInfo->append( QString( "<b>%1:</b>" ).arg( SMESHGUI_ElemInfo::tr( "CONNECTIVITY" ) ) );
1352             QString con = formatConnectivity( connectivity, SMDSAbs_0DElement );
1353             if ( !con.isEmpty() )
1354               myInfo->append( QString( "- <b>%1:</b> %2" ).arg( SMESHGUI_ElemInfo::tr( "0D_ELEMENTS" ) ).arg( con ) );
1355             con = formatConnectivity( connectivity, SMDSAbs_Edge );
1356             if ( !con.isEmpty() )
1357               myInfo->append( QString( "- <b>%1:</b> %2" ).arg( SMESHGUI_ElemInfo::tr( "EDGES" ) ).arg( con ) );
1358             con = formatConnectivity( connectivity, SMDSAbs_Face );
1359             if ( !con.isEmpty() )
1360               myInfo->append( QString( "- <b>%1:</b> %2" ).arg( SMESHGUI_ElemInfo::tr( "FACES" ) ).arg( con ) );
1361             con = formatConnectivity( connectivity, SMDSAbs_Volume );
1362             if ( !con.isEmpty() )
1363               myInfo->append( QString( "- <b>%1:</b> %2" ).arg( SMESHGUI_ElemInfo::tr( "VOLUMES" ) ).arg( con ) );
1364           }
1365           else {
1366             myInfo->append( QString( "<b>%1</b>" ).arg( SMESHGUI_ElemInfo::tr( "FREE_NODE" ) ).arg( id ) );
1367           }
1368         }
1369         // separator
1370         myInfo->append( "" );
1371
1372         // Controls
1373         myInfo->append( QString( "<b>%1:</b>" ).arg( SMESHGUI_ElemInfo::tr( "CONTROLS" ) ) );
1374         //Length
1375         if ( e->GetType() == SMDSAbs_Edge ) {
1376           afunctor.reset( new SMESH::Controls::Length() );
1377           afunctor->SetMesh( actor()->GetObject()->GetMesh() );
1378           afunctor->SetPrecision( cprecision );
1379           myInfo->append( QString( "- <b>%1:</b> %2" ).arg( tr( "LENGTH_EDGES" ) ).arg( afunctor->GetValue( id ) ) );  
1380         }
1381         if( e->GetType() == SMDSAbs_Face ) {
1382           //Area
1383           afunctor.reset(  new SMESH::Controls::Area() );
1384           afunctor->SetMesh( actor()->GetObject()->GetMesh() );
1385           afunctor->SetPrecision( cprecision );  
1386           myInfo->append( QString( "- <b>%1:</b> %2" ).arg( tr( "AREA_ELEMENTS" ) ).arg( afunctor->GetValue( id ) ) );
1387           //Taper
1388           afunctor.reset( new SMESH::Controls::Taper() );
1389           afunctor->SetMesh( actor()->GetObject()->GetMesh() );  
1390           afunctor->SetPrecision( cprecision );
1391           myInfo->append( QString( "- <b>%1:</b> %2" ).arg( tr( "TAPER_ELEMENTS" ) ).arg( afunctor->GetValue( id ) ) );
1392           //AspectRatio2D
1393           afunctor.reset( new SMESH::Controls::AspectRatio() );
1394           afunctor->SetMesh( actor()->GetObject()->GetMesh() );
1395           myInfo->append( QString( "- <b>%1:</b> %2" ).arg( tr( "ASPECTRATIO_ELEMENTS" ) ).arg( afunctor->GetValue( id ) ) );
1396           //Minimum angle         
1397           afunctor.reset( new SMESH::Controls::MinimumAngle() );
1398           afunctor->SetMesh( actor()->GetObject()->GetMesh() );
1399           afunctor->SetPrecision( cprecision );
1400           myInfo->append( QString( "- <b>%1:</b> %2" ).arg( tr( "MINIMUMANGLE_ELEMENTS" ) ).arg( afunctor->GetValue( id ) ) );
1401           //Wraping angle        
1402           afunctor.reset( new SMESH::Controls::Warping() );
1403           afunctor->SetMesh( actor()->GetObject()->GetMesh() );
1404           afunctor->SetPrecision( cprecision );
1405           myInfo->append( QString( "- <b>%1:</b> %2" ).arg( tr( "WARP_ELEMENTS" ) ).arg( afunctor->GetValue( id ) ) );
1406           //Skew         
1407           afunctor.reset( new SMESH::Controls::Skew() );
1408           afunctor->SetMesh( actor()->GetObject()->GetMesh() );
1409           afunctor->SetPrecision( cprecision );
1410           myInfo->append( QString( "- <b>%1:</b> %2" ).arg( tr( "SKEW_ELEMENTS" ) ).arg( afunctor->GetValue( id ) ) );
1411           //ElemDiam2D   
1412           afunctor.reset( new SMESH::Controls::MaxElementLength2D() );
1413           afunctor->SetMesh( actor()->GetObject()->GetMesh() );
1414           myInfo->append( QString( "- <b>%1:</b> %2" ).arg( tr( "MAX_ELEMENT_LENGTH_2D" ) ).arg( afunctor->GetValue( id ) ) );
1415         }
1416         if( e->GetType() == SMDSAbs_Volume ) {
1417           //AspectRatio3D
1418           afunctor.reset(  new SMESH::Controls::AspectRatio3D() );
1419           afunctor->SetMesh( actor()->GetObject()->GetMesh() );
1420           myInfo->append( QString( "- <b>%1:</b> %2" ).arg( tr( "ASPECTRATIO_3D_ELEMENTS" ) ).arg( afunctor->GetValue( id ) ) );
1421           //Volume      
1422           afunctor.reset(  new SMESH::Controls::Volume() );
1423           afunctor->SetMesh( actor()->GetObject()->GetMesh() );
1424           myInfo->append( QString( "- <b>%1:</b> %2" ).arg( tr( "VOLUME_3D_ELEMENTS" ) ).arg( afunctor->GetValue( id ) ) );
1425           //ElementDiameter3D    
1426           afunctor.reset(  new SMESH::Controls::Volume() );
1427           afunctor->SetMesh( actor()->GetObject()->GetMesh() );
1428           myInfo->append( QString( "- <b>%1:</b> %2" ).arg( tr( "MAX_ELEMENT_LENGTH_3D" ) ).arg( afunctor->GetValue( id ) ) );
1429         }
1430         // separator
1431         myInfo->append( "" );
1432
1433         // Gravity center
1434         XYZ gc = gravityCenter( e );
1435         myInfo->append( QString( "<b>%1:</b> (%2, %3, %4)" ).arg( SMESHGUI_ElemInfo::tr( "GRAVITY_CENTER" ) ).arg( gc.x() ).arg( gc.y() ).arg( gc.z() ) );
1436         
1437         // Normal vector
1438         if( e->GetType() == SMDSAbs_Face ) {
1439           XYZ gc = normal( e );
1440           myInfo->append( QString( "<b>%1:</b> (%2, %3, %4)" ).arg( SMESHGUI_ElemInfo::tr( "NORMAL_VECTOR" ) ).arg( gc.x() ).arg( gc.y() ).arg( gc.z() ) );
1441         }
1442
1443         // Element position
1444         if ( e->GetType() >= SMDSAbs_Edge && e->GetType() <= SMDSAbs_Volume ) {
1445           SMESH::SMESH_Mesh_ptr aMesh = actor()->GetObject()->GetMeshServer();    
1446           if ( !CORBA::is_nil( aMesh ) ) {
1447             SMESH::ElementPosition pos = aMesh->GetElementPosition( id );
1448             int shapeID = pos.shapeID;
1449             if ( shapeID > 0 ) {
1450               myInfo->append( "" ); // separator
1451               QString shapeType;
1452               switch ( pos.shapeType ) {
1453               case GEOM::EDGE:   shapeType = SMESHGUI_ElemInfo::tr( "GEOM_EDGE" );   break;
1454               case GEOM::FACE:   shapeType = SMESHGUI_ElemInfo::tr( "GEOM_FACE" );   break;
1455               case GEOM::VERTEX: shapeType = SMESHGUI_ElemInfo::tr( "GEOM_VERTEX" ); break;
1456               case GEOM::SOLID:  shapeType = SMESHGUI_ElemInfo::tr( "GEOM_SOLID" );  break;
1457               case GEOM::SHELL:  shapeType = SMESHGUI_ElemInfo::tr( "GEOM_SHELL" );  break;
1458               default:           shapeType = SMESHGUI_ElemInfo::tr( "GEOM_SHAPE" );  break;
1459               }
1460               myInfo->append( QString( "<b>%1:</b> %2 #%3" ).arg( SMESHGUI_ElemInfo::tr( "POSITION" ) ).arg( shapeType ).arg( shapeID ) );
1461             }
1462           }
1463         }
1464
1465         // Groups the element belongs to
1466         SMESH::SMESH_Mesh_ptr aMesh = actor()->GetObject()->GetMeshServer();
1467         if ( !CORBA::is_nil( aMesh ) ) {
1468           SMESH::ListOfGroups_var  groups = aMesh->GetGroups();
1469           myInfo->append( "" ); // separator
1470           bool top_created = false;
1471           for ( int i = 0; i < groups->length(); i++ ) {
1472             SMESH::SMESH_GroupBase_var aGrp = groups[i];
1473             if ( CORBA::is_nil( aGrp ) ) continue;
1474             QString aName = aGrp->GetName();
1475             if ( aGrp->GetType() != SMESH::NODE && !aName.isEmpty() && aGrp->Contains( id ) ) {
1476               if ( !top_created ) {
1477                 myInfo->append( QString( "<b>%1:</b>" ).arg( SMESHGUI_AddInfo::tr( "GROUPS" ) ) );
1478                 top_created = true;
1479               }
1480               myInfo->append( QString( "+ <b>%1:</b>" ).arg( aName.trimmed() ) );
1481               if ( grp_details ) {
1482                 SMESH::SMESH_Group_var         aStdGroup  = SMESH::SMESH_Group::_narrow( aGrp );
1483                 SMESH::SMESH_GroupOnGeom_var   aGeomGroup = SMESH::SMESH_GroupOnGeom::_narrow( aGrp );
1484                 SMESH::SMESH_GroupOnFilter_var aFltGroup  = SMESH::SMESH_GroupOnFilter::_narrow( aGrp );
1485                 
1486                 // type : group on geometry, standalone group, group on filter
1487                 if ( !CORBA::is_nil( aStdGroup ) ) {
1488                   myInfo->append( QString( "  - <b>%1:</b> %2" ).arg( SMESHGUI_AddInfo::tr( "TYPE" ) ).
1489                                   arg( SMESHGUI_AddInfo::tr( "STANDALONE_GROUP" ) ) );
1490                 }
1491                 else if ( !CORBA::is_nil( aGeomGroup ) ) {
1492                   myInfo->append( QString( "  - <b>%1:</b> %2" ).arg( SMESHGUI_AddInfo::tr( "TYPE" ) ).
1493                                   arg( SMESHGUI_AddInfo::tr( "GROUP_ON_GEOMETRY" ) ) );
1494                   GEOM::GEOM_Object_var gobj = aGeomGroup->GetShape();
1495                   _PTR(SObject) sobj = SMESH::ObjectToSObject( gobj );
1496                   if ( sobj ) {
1497                     myInfo->append( QString( "  - <b>%1:</b> %2: %3" ).arg( SMESHGUI_AddInfo::tr( "TYPE" ) ).
1498                                     arg( SMESHGUI_AddInfo::tr( "GEOM_OBJECT" ) ).arg( sobj->GetName().c_str() ) );
1499                   }
1500                 }
1501                 else if ( !CORBA::is_nil( aFltGroup ) ) {
1502                   myInfo->append( QString( "  - <b>%1:</b> %2" ).arg( SMESHGUI_AddInfo::tr( "TYPE" ) ).
1503                                   arg( SMESHGUI_AddInfo::tr( "GROUP_ON_FILTER" ) ) );
1504                 }
1505                 
1506                 myInfo->append( QString( "  - <b>%1:</b> %2" ).arg( SMESHGUI_AddInfo::tr( "SIZE" ) ).
1507                                 arg( QString::number( aGrp->Size() ) ) );
1508                 
1509                 // color
1510                 SALOMEDS::Color color = aGrp->GetColor();
1511                 myInfo->append( QString( "  - <b>%1:</b> %2" ).arg( SMESHGUI_AddInfo::tr( "COLOR" ) ).
1512                                 arg( QColor( color.R*255., color.G*255., color.B*255. ).name() ) );
1513               }
1514             }
1515           }
1516         }
1517       }
1518       // separator
1519       if ( ids.count() > 1 ) {
1520         myInfo->append( "" );
1521         myInfo->append( "------" );
1522         myInfo->append( "" );
1523       }
1524     }
1525   }
1526 }
1527
1528 /*!
1529   \brief Internal clean-up (reset widget)
1530 */
1531 void SMESHGUI_SimpleElemInfo::clearInternal()
1532 {
1533   myInfo->clear();
1534 }
1535
1536 void SMESHGUI_SimpleElemInfo::saveInfo( QTextStream &out )
1537 {
1538   out << QString( 12, '-' ) << "\n";
1539   out << SMESHGUI_ElemInfo::tr( "ELEM_INFO" ) << "\n";
1540   out << QString( 12, '-' ) << "\n";
1541   out << myInfo->toPlainText();
1542   out << "\n";
1543 }
1544
1545
1546 /*!
1547   \class SMESHGUI_TreeElemInfo::ItemDelegate
1548   \brief Item delegate for tree mesh info widget
1549   \internal
1550 */
1551 class SMESHGUI_TreeElemInfo::ItemDelegate : public QItemDelegate
1552 {
1553 public:
1554   ItemDelegate( QObject* );
1555   QWidget* createEditor( QWidget*, const QStyleOptionViewItem&, const QModelIndex& ) const;
1556 };
1557
1558 /*!
1559   \brief Constructor
1560   \internal
1561 */
1562 SMESHGUI_TreeElemInfo::ItemDelegate::ItemDelegate( QObject* parent ) : QItemDelegate( parent )
1563 {
1564 }
1565
1566 /*!
1567   \brief Create item editor widget
1568   \internal
1569 */
1570 QWidget* SMESHGUI_TreeElemInfo::ItemDelegate::createEditor( QWidget* parent, const QStyleOptionViewItem& option, const QModelIndex& index ) const
1571 {
1572   QWidget* w = index.column() == 0 ? 0: QItemDelegate::createEditor( parent, option, index );
1573   if ( qobject_cast<QLineEdit*>( w ) ) qobject_cast<QLineEdit*>( w )->setReadOnly(  true );
1574   return w;
1575 }
1576
1577 /*!
1578   \class SMESHGUI_TreeElemInfo
1579   \brief Represents mesh element information in the tree-like form.
1580 */
1581
1582 /*!
1583   \brief Constructor
1584   \param parent parent widget
1585 */
1586 SMESHGUI_TreeElemInfo::SMESHGUI_TreeElemInfo( QWidget* parent )
1587 : SMESHGUI_ElemInfo( parent )
1588 {
1589   myInfo = new QTreeWidget( frame() );
1590   myInfo->setColumnCount( 2 );
1591   myInfo->setHeaderLabels( QStringList() << tr( "PROPERTY" ) << tr( "VALUE" ) );
1592   myInfo->header()->setStretchLastSection( true );
1593   myInfo->header()->setResizeMode( 0, QHeaderView::ResizeToContents );
1594   myInfo->setItemDelegate( new ItemDelegate( myInfo ) );
1595   QVBoxLayout* l = new QVBoxLayout( frame() );
1596   l->setMargin( 0 );
1597   l->addWidget( myInfo );
1598   connect( myInfo, SIGNAL( itemDoubleClicked( QTreeWidgetItem*, int ) ), this, SLOT( itemDoubleClicked( QTreeWidgetItem*, int ) ) );
1599 }
1600
1601 /*!
1602   \brief Show mesh element information
1603   \param ids mesh nodes / elements identifiers
1604 */
1605 void SMESHGUI_TreeElemInfo::information( const QList<long>& ids )
1606 {
1607   clearInternal();
1608
1609   if ( actor() ) {
1610     int grp_details = SMESHGUI::resourceMgr()->booleanValue( "SMESH", "elem_info_grp_details", false );
1611     int precision   = SMESHGUI::resourceMgr()->integerValue( "SMESH", "length_precision", 6 );
1612     int cprecision = -1;
1613     if ( SMESHGUI::resourceMgr()->booleanValue( "SMESH", "use_precision", false ) ) 
1614       cprecision = SMESHGUI::resourceMgr()->integerValue( "SMESH", "controls_precision", -1 );
1615     foreach ( long id, ids ) {
1616       if ( !isElements() ) {
1617         //
1618         // show node info
1619         //
1620         const SMDS_MeshElement* e = actor()->GetObject()->GetMesh()->FindNode( id );
1621         if ( !e ) return;
1622         const SMDS_MeshNode* node = static_cast<const SMDS_MeshNode*>( e );
1623       
1624         // node ID
1625         QTreeWidgetItem* nodeItem = createItem( 0, Bold | All );
1626         nodeItem->setText( 0, SMESHGUI_ElemInfo::tr( "NODE" ) );
1627         nodeItem->setText( 1, QString( "#%1" ).arg( id ) );
1628         // coordinates
1629         QTreeWidgetItem* coordItem = createItem( nodeItem, Bold );
1630         coordItem->setText( 0, SMESHGUI_ElemInfo::tr( "COORDINATES" ) );
1631         QTreeWidgetItem* xItem = createItem( coordItem );
1632         xItem->setText( 0, "X" );
1633         xItem->setText( 1, QString::number( node->X(), precision > 0 ? 'f' : 'g', qAbs( precision ) ) );
1634         QTreeWidgetItem* yItem = createItem( coordItem );
1635         yItem->setText( 0, "Y" );
1636         yItem->setText( 1, QString::number( node->Y(), precision > 0 ? 'f' : 'g', qAbs( precision ) ) );
1637         QTreeWidgetItem* zItem = createItem( coordItem );
1638         zItem->setText( 0, "Z" );
1639         zItem->setText( 1, QString::number( node->Z(), precision > 0 ? 'f' : 'g', qAbs( precision ) ) );
1640         // connectivity
1641         QTreeWidgetItem* conItem = createItem( nodeItem, Bold );
1642         conItem->setText( 0, SMESHGUI_ElemInfo::tr( "CONNECTIVITY" ) );
1643         Connectivity connectivity = nodeConnectivity( node );
1644         if ( !connectivity.isEmpty() ) {
1645           QString con = formatConnectivity( connectivity, SMDSAbs_0DElement );
1646           if ( !con.isEmpty() ) {
1647             QTreeWidgetItem* i = createItem( conItem );
1648             i->setText( 0, SMESHGUI_ElemInfo::tr( "0D_ELEMENTS" ) );
1649             i->setText( 1, con );
1650           }
1651           con = formatConnectivity( connectivity, SMDSAbs_Ball );
1652           if ( !con.isEmpty() ) {
1653             QTreeWidgetItem* i = createItem( conItem );
1654             i->setText( 0, SMESHGUI_ElemInfo::tr( "BALL_ELEMENTS" ) );
1655             i->setText( 1, con );
1656             i->setData( 1, TypeRole, NodeConnectivity );
1657           }
1658           con = formatConnectivity( connectivity, SMDSAbs_Edge );
1659           if ( !con.isEmpty() ) {
1660             QTreeWidgetItem* i = createItem( conItem );
1661             i->setText( 0, SMESHGUI_ElemInfo::tr( "EDGES" ) );
1662             i->setText( 1, con );
1663             i->setData( 1, TypeRole, NodeConnectivity );
1664           }
1665           con = formatConnectivity( connectivity, SMDSAbs_Face );
1666           if ( !con.isEmpty() ) {
1667             QTreeWidgetItem* i = createItem( conItem );
1668             i->setText( 0, SMESHGUI_ElemInfo::tr( "FACES" ) );
1669             i->setText( 1, con );
1670             i->setData( 1, TypeRole, NodeConnectivity );
1671           }
1672           con = formatConnectivity( connectivity, SMDSAbs_Volume );
1673           if ( !con.isEmpty() ) {
1674             QTreeWidgetItem* i = createItem( conItem );
1675             i->setText( 0, SMESHGUI_ElemInfo::tr( "VOLUMES" ) );
1676             i->setText( 1, con );
1677             i->setData( 1, TypeRole, NodeConnectivity );
1678           }
1679         }
1680         else {
1681           conItem->setText( 1, SMESHGUI_ElemInfo::tr( "FREE_NODE" ) );
1682         }
1683         // node position
1684         SMESH::SMESH_Mesh_ptr aMeshPtr = actor()->GetObject()->GetMeshServer();   
1685         if ( !CORBA::is_nil( aMeshPtr ) ) {
1686           SMESH::NodePosition_var pos = aMeshPtr->GetNodePosition( id );
1687           int shapeID = pos->shapeID;
1688           if ( shapeID > 0 ) {
1689             QString shapeType;
1690             double u, v;
1691             switch ( pos->shapeType ) {
1692             case GEOM::EDGE:
1693               shapeType = SMESHGUI_ElemInfo::tr( "GEOM_EDGE" );
1694               if ( pos->params.length() == 1 )
1695                 u = pos->params[0];
1696               break;
1697             case GEOM::FACE:
1698               shapeType = SMESHGUI_ElemInfo::tr( "GEOM_FACE" );
1699               if ( pos->params.length() == 2 ) {
1700                 u = pos->params[0];
1701                 v = pos->params[1];
1702               }
1703               break;
1704             case GEOM::VERTEX:
1705               shapeType = SMESHGUI_ElemInfo::tr( "GEOM_VERTEX" );
1706               break;
1707             default:
1708               shapeType = SMESHGUI_ElemInfo::tr( "GEOM_SOLID" );
1709               break;
1710             }
1711             QTreeWidgetItem* posItem = createItem( nodeItem, Bold );
1712             posItem->setText( 0, SMESHGUI_ElemInfo::tr("POSITION") );
1713             posItem->setText( 1, (shapeType + " #%1").arg( shapeID ));
1714             if ( pos->shapeType == GEOM::EDGE || pos->shapeType == GEOM::FACE ) {
1715               QTreeWidgetItem* uItem = createItem( posItem );
1716               uItem->setText( 0, SMESHGUI_ElemInfo::tr("U_POSITION") );
1717               uItem->setText( 1, QString::number( u, precision > 0 ? 'f' : 'g', qAbs( precision )));
1718               if ( pos->shapeType == GEOM::FACE ) {
1719                 QTreeWidgetItem* vItem = createItem( posItem );
1720                 vItem->setText( 0, SMESHGUI_ElemInfo::tr("V_POSITION") );
1721                 vItem->setText( 1, QString::number( v, precision > 0 ? 'f' : 'g', qAbs( precision )));
1722               }
1723             }
1724           }
1725         }
1726         // groups node belongs to
1727         SMESH::SMESH_Mesh_ptr aMesh = actor()->GetObject()->GetMeshServer();
1728         if ( !CORBA::is_nil( aMesh ) ) {
1729           SMESH::ListOfGroups_var groups = aMesh->GetGroups();
1730           QTreeWidgetItem* groupsItem = 0;
1731           for ( int i = 0; i < groups->length(); i++ ) {
1732             SMESH::SMESH_GroupBase_var aGrp = groups[i];
1733             if ( CORBA::is_nil( aGrp ) ) continue;
1734             QString aName = aGrp->GetName();
1735             if ( aGrp->GetType() == SMESH::NODE && !aName.isEmpty() && aGrp->Contains( id ) ) {
1736               if ( !groupsItem ) {
1737                 groupsItem = createItem( nodeItem, Bold );
1738                 groupsItem->setText( 0, SMESHGUI_AddInfo::tr( "GROUPS" ) );
1739               }
1740               QTreeWidgetItem* it = createItem( groupsItem, Bold );
1741               it->setText( 0, aName.trimmed() );
1742               if ( grp_details ) {
1743                 SMESH::SMESH_Group_var         aStdGroup  = SMESH::SMESH_Group::_narrow( aGrp );
1744                 SMESH::SMESH_GroupOnGeom_var   aGeomGroup = SMESH::SMESH_GroupOnGeom::_narrow( aGrp );
1745                 SMESH::SMESH_GroupOnFilter_var aFltGroup  = SMESH::SMESH_GroupOnFilter::_narrow( aGrp );
1746                 
1747                 // type : group on geometry, standalone group, group on filter
1748                 QTreeWidgetItem* typeItem = createItem( it );
1749                 typeItem->setText( 0, SMESHGUI_AddInfo::tr( "TYPE" ) );
1750                 if ( !CORBA::is_nil( aStdGroup ) ) {
1751                   typeItem->setText( 1, SMESHGUI_AddInfo::tr( "STANDALONE_GROUP" ) );
1752                 }
1753                 else if ( !CORBA::is_nil( aGeomGroup ) ) {
1754                   typeItem->setText( 1, SMESHGUI_AddInfo::tr( "GROUP_ON_GEOMETRY" ) );
1755                   GEOM::GEOM_Object_var gobj = aGeomGroup->GetShape();
1756                   _PTR(SObject) sobj = SMESH::ObjectToSObject( gobj );
1757                   if ( sobj ) {
1758                     QTreeWidgetItem* gobjItem = createItem( typeItem );
1759                     gobjItem->setText( 0, SMESHGUI_AddInfo::tr( "GEOM_OBJECT" ) );
1760                     gobjItem->setText( 1, sobj->GetName().c_str() );
1761                   }
1762                 }
1763                 else if ( !CORBA::is_nil( aFltGroup ) ) {
1764                   typeItem->setText( 1, SMESHGUI_AddInfo::tr( "GROUP_ON_FILTER" ) );
1765                 }
1766                 
1767                 // size
1768                 QTreeWidgetItem* sizeItem = createItem( it );
1769                 sizeItem->setText( 0, SMESHGUI_AddInfo::tr( "SIZE" ) );
1770                 sizeItem->setText( 1, QString::number( aGrp->Size() ) );
1771                 
1772                 // color
1773                 SALOMEDS::Color color = aGrp->GetColor();
1774                 QTreeWidgetItem* colorItem = createItem( it );
1775                 colorItem->setText( 0, SMESHGUI_AddInfo::tr( "COLOR" ) );
1776                 colorItem->setBackground( 1, QBrush( QColor( color.R*255., color.G*255., color.B*255.) ) );
1777               }
1778             }
1779           }
1780         }
1781       }
1782       else {
1783         //
1784         // show element info
1785         // 
1786         const SMDS_MeshElement* e = actor()->GetObject()->GetMesh()->FindElement( id );
1787         SMESH::Controls::NumericalFunctorPtr afunctor;
1788         if ( !e ) return;
1789         
1790         // element ID && type
1791         QString stype;
1792         switch( e->GetType() ) {
1793         case SMDSAbs_0DElement: stype = SMESHGUI_ElemInfo::tr( "0D_ELEMENT" ); break;
1794         case SMDSAbs_Ball:      stype = SMESHGUI_ElemInfo::tr( "BALL" ); break;
1795         case SMDSAbs_Edge:      stype = SMESHGUI_ElemInfo::tr( "EDGE" ); break;
1796         case SMDSAbs_Face:      stype = SMESHGUI_ElemInfo::tr( "FACE" ); break;
1797         case SMDSAbs_Volume:    stype = SMESHGUI_ElemInfo::tr( "VOLUME" ); break;
1798         default:;
1799         }
1800         if ( stype.isEmpty() ) return;
1801         QTreeWidgetItem* elemItem = createItem( 0, Bold | All );
1802         elemItem->setText( 0, stype );
1803         elemItem->setText( 1, QString( "#%1" ).arg( id ) );
1804         // geometry type
1805         QString gtype;
1806         switch( e->GetEntityType() ) {
1807         case SMDSEntity_Triangle:
1808         case SMDSEntity_Quad_Triangle:
1809         case SMDSEntity_BiQuad_Triangle:
1810           gtype = SMESHGUI_ElemInfo::tr( "TRIANGLE" ); break;
1811         case SMDSEntity_Quadrangle:
1812         case SMDSEntity_Quad_Quadrangle:
1813         case SMDSEntity_BiQuad_Quadrangle:
1814           gtype = SMESHGUI_ElemInfo::tr( "QUADRANGLE" ); break;
1815         case SMDSEntity_Polygon:
1816         case SMDSEntity_Quad_Polygon:
1817           gtype = SMESHGUI_ElemInfo::tr( "POLYGON" ); break;
1818         case SMDSEntity_Tetra:
1819         case SMDSEntity_Quad_Tetra:
1820           gtype = SMESHGUI_ElemInfo::tr( "TETRAHEDRON" ); break;
1821         case SMDSEntity_Pyramid:
1822         case SMDSEntity_Quad_Pyramid:
1823           gtype = SMESHGUI_ElemInfo::tr( "PYRAMID" ); break;
1824         case SMDSEntity_Hexa:
1825         case SMDSEntity_Quad_Hexa:
1826         case SMDSEntity_TriQuad_Hexa:
1827           gtype = SMESHGUI_ElemInfo::tr( "HEXAHEDRON" ); break;
1828         case SMDSEntity_Penta:
1829         case SMDSEntity_Quad_Penta:
1830           gtype = SMESHGUI_ElemInfo::tr( "PRISM" ); break;
1831         case SMDSEntity_Hexagonal_Prism:
1832           gtype = SMESHGUI_ElemInfo::tr( "HEX_PRISM" ); break;
1833         case SMDSEntity_Polyhedra:
1834         case SMDSEntity_Quad_Polyhedra:
1835           gtype = SMESHGUI_ElemInfo::tr( "POLYHEDRON" ); break;
1836         default: 
1837           break;
1838         }
1839         if ( !gtype.isEmpty() ) {
1840           QTreeWidgetItem* typeItem = createItem( elemItem, Bold );
1841           typeItem->setText( 0, SMESHGUI_ElemInfo::tr( "TYPE" ) );
1842           typeItem->setText( 1, gtype );
1843         }
1844         // quadratic flag (for edges, faces and volumes)
1845         if ( e->GetType() >= SMDSAbs_Edge && e->GetType() <= SMDSAbs_Volume ) {
1846           // quadratic flag
1847           QTreeWidgetItem* quadItem = createItem( elemItem, Bold );
1848           quadItem->setText( 0, SMESHGUI_ElemInfo::tr( "QUADRATIC" ) );
1849           quadItem->setText( 1, e->IsQuadratic() ? SMESHGUI_ElemInfo::tr( "YES" ) : SMESHGUI_ElemInfo::tr( "NO" ) );
1850         }
1851         if ( const SMDS_BallElement* ball = dynamic_cast<const SMDS_BallElement*>( e )) {
1852           // ball diameter
1853           QTreeWidgetItem* diamItem = createItem( elemItem, Bold );
1854           diamItem->setText( 0, SMESHGUI_ElemInfo::tr( "BALL_DIAMETER" ) );
1855           diamItem->setText( 1, QString( "%1" ).arg( ball->GetDiameter() ));
1856         }
1857         // connectivity
1858         QTreeWidgetItem* conItem = createItem( elemItem, Bold );
1859         conItem->setText( 0, SMESHGUI_ElemInfo::tr( "CONNECTIVITY" ) );
1860
1861
1862         if( e->GetGeomType() != SMDSGeom_POLYHEDRA ) {
1863           SMDS_ElemIteratorPtr nodeIt = e->nodesIterator();
1864           for ( int idx = 1; nodeIt->more(); idx++ ) {
1865             const SMDS_MeshNode* node = static_cast<const SMDS_MeshNode*>( nodeIt->next() );
1866             nodeInfo( node, idx, e->NbNodes(), conItem );
1867           }
1868         }
1869         else {
1870           const SMDS_VtkVolume* aVtkVolume = dynamic_cast<const SMDS_VtkVolume*>(e);
1871           SMDS_ElemIteratorPtr nodeIt = aVtkVolume->uniqueNodesIterator();
1872           QList<const SMDS_MeshElement*> uniqueNodes;
1873           while ( nodeIt->more() )
1874             uniqueNodes.append( nodeIt->next() );
1875
1876           SMDS_VolumeTool vtool( e );
1877           const int nbFaces = vtool.NbFaces();
1878           for( int face_id = 0; face_id < nbFaces; face_id++ ) {
1879             QTreeWidgetItem* faceItem = createItem( conItem, Bold );
1880             faceItem->setText( 0, QString( "%1 %2 / %3" ).arg( SMESHGUI_ElemInfo::tr( "FACE" ) ).arg( face_id + 1 ).arg( nbFaces ) );
1881             faceItem->setExpanded( true );
1882
1883             const SMDS_MeshNode** aNodeIds = vtool.GetFaceNodes( face_id );
1884             const int nbNodes = vtool.NbFaceNodes( face_id );
1885             for( int node_id = 0; node_id < nbNodes; node_id++ ) {
1886               const SMDS_MeshNode* node = aNodeIds[node_id];
1887               nodeInfo( node, uniqueNodes.indexOf(node) + 1, aVtkVolume->NbUniqueNodes(), faceItem );
1888             }
1889           }
1890         }
1891         //Controls
1892         QTreeWidgetItem* cntrItem = createItem( elemItem, Bold );
1893         cntrItem->setText( 0, SMESHGUI_ElemInfo::tr( "CONTROLS" ) );
1894         //Length
1895         if( e->GetType()==SMDSAbs_Edge){         
1896           afunctor.reset( new SMESH::Controls::Length() );
1897           afunctor->SetMesh( actor()->GetObject()->GetMesh() );
1898           afunctor->SetPrecision( cprecision );
1899           QTreeWidgetItem* lenItem = createItem( cntrItem, Bold );
1900           lenItem->setText( 0, tr( "LENGTH_EDGES" ) );
1901           lenItem->setText( 1, QString( "%1" ).arg( afunctor->GetValue( id ) ) );         
1902         }
1903         if( e->GetType() == SMDSAbs_Face ) {
1904           //Area         
1905           afunctor.reset( new SMESH::Controls::Area() );        
1906           afunctor->SetMesh( actor()->GetObject()->GetMesh() );
1907           afunctor->SetPrecision( cprecision );
1908           QTreeWidgetItem* areaItem = createItem( cntrItem, Bold );
1909           areaItem->setText( 0, tr( "AREA_ELEMENTS" ) );
1910           areaItem->setText( 1, QString( "%1" ).arg( afunctor->GetValue(id) ) );         
1911           //Taper
1912           afunctor.reset( new SMESH::Controls::Taper() );
1913           afunctor->SetMesh( actor()->GetObject()->GetMesh() );
1914           afunctor->SetPrecision( cprecision );
1915           QTreeWidgetItem* taperlItem = createItem( cntrItem, Bold );
1916           taperlItem->setText( 0, tr( "TAPER_ELEMENTS" ) );
1917           taperlItem->setText( 1, QString( "%1" ).arg( afunctor->GetValue( id ) ) );    
1918           //AspectRatio2D
1919           afunctor.reset( new SMESH::Controls::AspectRatio() );
1920           afunctor->SetMesh( actor()->GetObject()->GetMesh() );  
1921           QTreeWidgetItem* ratlItem = createItem( cntrItem, Bold );
1922           ratlItem->setText( 0, tr( "ASPECTRATIO_ELEMENTS" ));
1923           ratlItem->setText( 1, QString( "%1" ).arg( afunctor->GetValue( id ) ) );      
1924           //Minimum angle
1925           afunctor.reset( new SMESH::Controls::MinimumAngle() );
1926           afunctor->SetMesh( actor()->GetObject()->GetMesh() );
1927           afunctor->SetPrecision( cprecision );
1928           QTreeWidgetItem* minanglItem = createItem( cntrItem, Bold );
1929           minanglItem->setText( 0, tr( "MINIMUMANGLE_ELEMENTS" ) );
1930           minanglItem->setText( 1, QString( "%1" ).arg( afunctor->GetValue( id ) ) );    
1931           //Wraping angle       
1932           afunctor.reset( new SMESH::Controls::Warping() );
1933           afunctor->SetMesh( actor()->GetObject()->GetMesh() );
1934           afunctor->SetPrecision( cprecision );
1935           QTreeWidgetItem* warpItem = createItem( cntrItem, Bold );
1936           warpItem->setText( 0, tr( "WARP_ELEMENTS" ));
1937           warpItem->setText( 1, QString( "%1" ).arg( afunctor->GetValue( id ) ) );        
1938           //Skew          
1939           afunctor.reset( new SMESH::Controls::Skew() );
1940           afunctor->SetMesh( actor()->GetObject()->GetMesh() );
1941           afunctor->SetPrecision( cprecision );
1942           QTreeWidgetItem* skewItem = createItem( cntrItem, Bold );
1943           skewItem->setText( 0, tr( "SKEW_ELEMENTS" ) );
1944           skewItem->setText( 1, QString( "%1" ).arg( afunctor->GetValue( id ) ) );       
1945           //ElemDiam2D    
1946           afunctor.reset( new SMESH::Controls::MaxElementLength2D() );
1947           afunctor->SetMesh( actor()->GetObject()->GetMesh() );
1948           QTreeWidgetItem* diamItem = createItem( cntrItem, Bold );
1949           diamItem->setText( 0, tr( "MAX_ELEMENT_LENGTH_2D" ));
1950           diamItem->setText( 1, QString( "%1" ).arg( afunctor->GetValue( id ) ) );       
1951         }
1952         if( e->GetType() == SMDSAbs_Volume ) {
1953           //AspectRatio3D
1954           afunctor.reset( new SMESH::Controls::AspectRatio3D() );
1955           afunctor->SetMesh( actor()->GetObject()->GetMesh() );
1956           QTreeWidgetItem* ratlItem3 = createItem( cntrItem, Bold );
1957           ratlItem3->setText( 0, tr( "ASPECTRATIO_3D_ELEMENTS" ) );
1958           ratlItem3->setText( 1, QString( "%1" ).arg( afunctor->GetValue( id ) ) );      
1959           //Volume
1960           afunctor.reset( new SMESH::Controls::Volume() );
1961           afunctor->SetMesh( actor()->GetObject()->GetMesh() );
1962           QTreeWidgetItem* volItem = createItem( cntrItem, Bold );
1963           volItem->setText( 0, tr( "VOLUME_3D_ELEMENTS" ) );
1964           volItem->setText( 1, QString( "%1" ).arg( afunctor->GetValue( id ) ) );
1965           //ElementDiameter3D
1966           afunctor.reset( new SMESH::Controls::MaxElementLength3D() );
1967           afunctor->SetMesh( actor()->GetObject()->GetMesh() );
1968           QTreeWidgetItem* diam3Item = createItem( cntrItem, Bold );
1969           diam3Item->setText( 0, tr( "MAX_ELEMENT_LENGTH_3D" ) );
1970           diam3Item->setText( 1, QString( "%1" ).arg( afunctor->GetValue( id ) ) );     
1971         }
1972
1973         // gravity center
1974         XYZ gc = gravityCenter( e );
1975         QTreeWidgetItem* gcItem = createItem( elemItem, Bold );
1976         gcItem->setText( 0, SMESHGUI_ElemInfo::tr( "GRAVITY_CENTER" ) );
1977         QTreeWidgetItem* xItem = createItem( gcItem );
1978         xItem->setText( 0, "X" );
1979         xItem->setText( 1, QString::number( gc.x(), precision > 0 ? 'f' : 'g', qAbs( precision ) ) );
1980         QTreeWidgetItem* yItem = createItem( gcItem );
1981         yItem->setText( 0, "Y" );
1982         yItem->setText( 1, QString::number( gc.y(), precision > 0 ? 'f' : 'g', qAbs( precision ) ) );
1983         QTreeWidgetItem* zItem = createItem( gcItem );
1984         zItem->setText( 0, "Z" );
1985         zItem->setText( 1, QString::number( gc.z(), precision > 0 ? 'f' : 'g', qAbs( precision ) ) );
1986
1987         // normal vector
1988         if( e->GetType() == SMDSAbs_Face ) {
1989           XYZ gc = normal( e );
1990           QTreeWidgetItem* nItem = createItem( elemItem, Bold );
1991           nItem->setText( 0, SMESHGUI_ElemInfo::tr( "NORMAL_VECTOR" ) );
1992           QTreeWidgetItem* xItem = createItem( nItem );
1993           xItem->setText( 0, "X" );
1994           xItem->setText( 1, QString::number( gc.x(), precision > 0 ? 'f' : 'g', qAbs( precision ) ) );
1995           QTreeWidgetItem* yItem = createItem( nItem );
1996           yItem->setText( 0, "Y" );
1997           yItem->setText( 1, QString::number( gc.y(), precision > 0 ? 'f' : 'g', qAbs( precision ) ) );
1998           QTreeWidgetItem* zItem = createItem( nItem );
1999           zItem->setText( 0, "Z" );
2000           zItem->setText( 1, QString::number( gc.z(), precision > 0 ? 'f' : 'g', qAbs( precision ) ) );
2001         }
2002
2003         // element position
2004         SMESH::SMESH_Mesh_ptr aMesh = actor()->GetObject()->GetMeshServer();
2005         if ( e->GetType() >= SMDSAbs_Edge && e->GetType() <= SMDSAbs_Volume ) {
2006           if ( !CORBA::is_nil( aMesh ) ) {
2007             SMESH::ElementPosition pos = aMesh->GetElementPosition( id );
2008             int shapeID = pos.shapeID;
2009             if ( shapeID > 0 ) {
2010               QTreeWidgetItem* shItem = createItem( elemItem, Bold );
2011               QString shapeType;
2012               switch ( pos.shapeType ) {
2013               case GEOM::EDGE:   shapeType = SMESHGUI_ElemInfo::tr( "GEOM_EDGE" );   break;
2014               case GEOM::FACE:   shapeType = SMESHGUI_ElemInfo::tr( "GEOM_FACE" );   break;
2015               case GEOM::VERTEX: shapeType = SMESHGUI_ElemInfo::tr( "GEOM_VERTEX" ); break;
2016               case GEOM::SOLID:  shapeType = SMESHGUI_ElemInfo::tr( "GEOM_SOLID" );  break;
2017               case GEOM::SHELL:  shapeType = SMESHGUI_ElemInfo::tr( "GEOM_SHELL" );  break;
2018               default:           shapeType = SMESHGUI_ElemInfo::tr( "GEOM_SHAPE" );  break;
2019               }
2020               shItem->setText( 0, SMESHGUI_ElemInfo::tr( "POSITION" ) );
2021               shItem->setText( 1, QString( "%1 #%2" ).arg( shapeType ).arg( shapeID ) );
2022             }
2023           }
2024         }
2025         // groups element belongs to
2026         if ( !CORBA::is_nil( aMesh ) ) {
2027           SMESH::ListOfGroups_var  groups = aMesh->GetGroups();
2028           QTreeWidgetItem* groupsItem = 0;
2029           for ( int i = 0; i < groups->length(); i++ ) {
2030             SMESH::SMESH_GroupBase_var aGrp = groups[i];
2031             if ( CORBA::is_nil( aGrp ) ) continue;
2032             QString aName = aGrp->GetName();
2033             if ( aGrp->GetType() != SMESH::NODE && !aName.isEmpty() && aGrp->Contains( id ) ) {
2034               if ( !groupsItem ) {
2035                 groupsItem = createItem( elemItem, Bold );
2036                 groupsItem->setText( 0, SMESHGUI_AddInfo::tr( "GROUPS" ) );
2037               }
2038               QTreeWidgetItem* it = createItem( groupsItem, Bold );
2039               it->setText( 0, aName.trimmed() );
2040               if ( grp_details ) {
2041                 SMESH::SMESH_Group_var         aStdGroup  = SMESH::SMESH_Group::_narrow( aGrp );
2042                 SMESH::SMESH_GroupOnGeom_var   aGeomGroup = SMESH::SMESH_GroupOnGeom::_narrow( aGrp );
2043                 SMESH::SMESH_GroupOnFilter_var aFltGroup  = SMESH::SMESH_GroupOnFilter::_narrow( aGrp );
2044                 
2045                 // type : group on geometry, standalone group, group on filter
2046                 QTreeWidgetItem* typeItem = createItem( it );
2047                 typeItem->setText( 0, SMESHGUI_AddInfo::tr( "TYPE" ) );
2048                 if ( !CORBA::is_nil( aStdGroup ) ) {
2049                   typeItem->setText( 1, SMESHGUI_AddInfo::tr( "STANDALONE_GROUP" ) );
2050                 }
2051                 else if ( !CORBA::is_nil( aGeomGroup ) ) {
2052                   typeItem->setText( 1, SMESHGUI_AddInfo::tr( "GROUP_ON_GEOMETRY" ) );
2053                   GEOM::GEOM_Object_var gobj = aGeomGroup->GetShape();
2054                   _PTR(SObject) sobj = SMESH::ObjectToSObject( gobj );
2055                   if ( sobj ) {
2056                     QTreeWidgetItem* gobjItem = createItem( typeItem );
2057                     gobjItem->setText( 0, SMESHGUI_AddInfo::tr( "GEOM_OBJECT" ) );
2058                     gobjItem->setText( 1, sobj->GetName().c_str() );
2059                   }
2060                 }
2061                 else if ( !CORBA::is_nil( aFltGroup ) ) {
2062                   typeItem->setText( 1, SMESHGUI_AddInfo::tr( "GROUP_ON_FILTER" ) );
2063                 }
2064                 
2065                 // size
2066                 QTreeWidgetItem* sizeItem = createItem( it );
2067                 sizeItem->setText( 0, SMESHGUI_AddInfo::tr( "SIZE" ) );
2068                 sizeItem->setText( 1, QString::number( aGrp->Size() ) );
2069                 
2070                 // color
2071                 SALOMEDS::Color color = aGrp->GetColor();
2072                 QTreeWidgetItem* colorItem = createItem( it );
2073                 colorItem->setText( 0, SMESHGUI_AddInfo::tr( "COLOR" ) );
2074                 colorItem->setBackground( 1, QBrush( QColor( color.R*255., color.G*255., color.B*255.) ) );
2075               }
2076             }
2077           }
2078         }
2079       }
2080     }
2081   }
2082 }
2083
2084 /*!
2085   \brief Show node information
2086   \param node mesh node for showing
2087   \param index index of current node
2088   \param nbNodes number of unique nodes in element
2089   \param parentItem parent item of tree
2090 */
2091 void SMESHGUI_TreeElemInfo::nodeInfo( const SMDS_MeshNode* node, int index,
2092                                       int nbNodes, QTreeWidgetItem* parentItem )
2093 {
2094   int precision   = SMESHGUI::resourceMgr()->integerValue( "SMESH", "length_precision", 6 );
2095   // node number and ID
2096   QTreeWidgetItem* nodeItem = createItem( parentItem, Bold );
2097   nodeItem->setText( 0, QString( "%1 %2 / %3" ).arg( SMESHGUI_ElemInfo::tr( "NODE" ) ).arg( index ).arg( nbNodes ) );
2098   nodeItem->setText( 1, QString( "#%1" ).arg( node->GetID() ) );
2099   nodeItem->setData( 1, TypeRole, ElemConnectivity );
2100   nodeItem->setData( 1, IdRole, node->GetID() );
2101   nodeItem->setExpanded( false );
2102   // node coordinates
2103   QTreeWidgetItem* coordItem = createItem( nodeItem );
2104   coordItem->setText( 0, SMESHGUI_ElemInfo::tr( "COORDINATES" ) );
2105   QTreeWidgetItem* xItem = createItem( coordItem );
2106   xItem->setText( 0, "X" );
2107   xItem->setText( 1, QString::number( node->X(), precision > 0 ? 'f' : 'g', qAbs( precision ) ) );
2108   QTreeWidgetItem* yItem = createItem( coordItem );
2109   yItem->setText( 0, "Y" );
2110   yItem->setText( 1, QString::number( node->Y(), precision > 0 ? 'f' : 'g', qAbs( precision ) ) );
2111   QTreeWidgetItem* zItem = createItem( coordItem );
2112   zItem->setText( 0, "Z" );
2113   zItem->setText( 1, QString::number( node->Z(), precision > 0 ? 'f' : 'g', qAbs( precision ) ) );
2114   // node connectivity
2115   QTreeWidgetItem* nconItem = createItem( nodeItem );
2116   nconItem->setText( 0, SMESHGUI_ElemInfo::tr( "CONNECTIVITY" ) );
2117   Connectivity connectivity = nodeConnectivity( node );
2118   if ( !connectivity.isEmpty() ) {
2119     QString con = formatConnectivity( connectivity, SMDSAbs_0DElement );
2120     if ( !con.isEmpty() ) {
2121       QTreeWidgetItem* i = createItem( nconItem );
2122       i->setText( 0, SMESHGUI_ElemInfo::tr( "0D_ELEMENTS" ) );
2123       i->setText( 1, con );
2124     }
2125     con = formatConnectivity( connectivity, SMDSAbs_Edge );
2126     if ( !con.isEmpty() ) {
2127       QTreeWidgetItem* i = createItem( nconItem );
2128       i->setText( 0, SMESHGUI_ElemInfo::tr( "EDGES" ) );
2129       i->setText( 1, con );
2130       i->setData( 1, TypeRole, NodeConnectivity );
2131     }
2132     con = formatConnectivity( connectivity, SMDSAbs_Ball );
2133     if ( !con.isEmpty() ) {
2134       QTreeWidgetItem* i = createItem( nconItem );
2135       i->setText( 0, SMESHGUI_ElemInfo::tr( "BALL_ELEMENTS" ) );
2136       i->setText( 1, con );
2137       i->setData( 1, TypeRole, NodeConnectivity );
2138     }
2139     con = formatConnectivity( connectivity, SMDSAbs_Face );
2140     if ( !con.isEmpty() ) {
2141       QTreeWidgetItem* i = createItem( nconItem );
2142       i->setText( 0, SMESHGUI_ElemInfo::tr( "FACES" ) );
2143       i->setText( 1, con );
2144       i->setData( 1, TypeRole, NodeConnectivity );
2145     }
2146     con = formatConnectivity( connectivity, SMDSAbs_Volume );
2147     if ( !con.isEmpty() ) {
2148       QTreeWidgetItem* i = createItem( nconItem );
2149       i->setText( 0, SMESHGUI_ElemInfo::tr( "VOLUMES" ) );
2150       i->setText( 1, con );
2151       i->setData( 1, TypeRole, NodeConnectivity );
2152     }
2153   }
2154 }
2155 /*!
2156   \brief Internal clean-up (reset widget)
2157 */
2158 void SMESHGUI_TreeElemInfo::clearInternal()
2159 {
2160   myInfo->clear();
2161   myInfo->repaint();
2162 }
2163
2164 /*!
2165   \brief Create new tree item.
2166   \param parent parent tree widget item
2167   \param flags item flag
2168   \return new tree widget item
2169 */
2170 QTreeWidgetItem* SMESHGUI_TreeElemInfo::createItem( QTreeWidgetItem* parent, int flags )
2171 {
2172   QTreeWidgetItem* item;
2173   if ( parent )
2174     item = new QTreeWidgetItem( parent );
2175   else
2176     item = new QTreeWidgetItem( myInfo );
2177
2178   item->setFlags( item->flags() | Qt::ItemIsEditable );
2179
2180   QFont f = item->font( 0 );
2181   f.setBold( true );
2182   for ( int i = 0; i < myInfo->columnCount(); i++ ) {
2183     if ( ( flags & Bold ) && ( i == 0 || flags & All ) )
2184       item->setFont( i, f );
2185   }
2186
2187   item->setExpanded( true );
2188   return item;
2189 }
2190
2191 void SMESHGUI_TreeElemInfo::contextMenuEvent( QContextMenuEvent* e )
2192 {
2193   QList< QTreeWidgetItem* > widgets = myInfo->selectedItems();
2194   if ( widgets.isEmpty() ) return;
2195   QTreeWidgetItem* aTreeItem = widgets.first();
2196   int type = aTreeItem->data( 1, TypeRole ).toInt();
2197   int id   = aTreeItem->data( 1, IdRole ).toInt();
2198   QMenu menu;
2199   QAction* a = menu.addAction( tr( "SHOW_ITEM_INFO" ) );
2200   if ( type == ElemConnectivity && id > 0 && menu.exec( e->globalPos() ) == a )
2201     emit( itemInfo( id ) );
2202   else if ( type == NodeConnectivity && menu.exec( e->globalPos() ) == a )
2203     emit( itemInfo( aTreeItem->text( 1 ) ) );
2204 }
2205
2206 void  SMESHGUI_TreeElemInfo::itemDoubleClicked( QTreeWidgetItem* theItem, int theColumn )
2207 {
2208   if ( theItem ) {
2209     int type = theItem->data( 1, TypeRole ).toInt();
2210     int id   = theItem->data( 1, IdRole ).toInt();
2211     if ( type == ElemConnectivity && id > 0 )
2212       emit( itemInfo( id ) );
2213     else if ( type == NodeConnectivity )
2214       emit( itemInfo( theItem->text( 1 ) ) );
2215   }
2216 }
2217
2218 void SMESHGUI_TreeElemInfo::saveInfo( QTextStream &out )
2219 {
2220   out << QString( 12, '-' ) << "\n";
2221   out << SMESHGUI_ElemInfo::tr( "ELEM_INFO" ) << "\n";
2222   out << QString( 12, '-' ) << "\n";
2223
2224   QTreeWidgetItemIterator it( myInfo );
2225   while ( *it ) {
2226     if ( !( *it )->text(0).isEmpty() ) {
2227       out << QString( SPACING_INFO * itemDepth( *it ), ' ' ) << ( *it )->text(0);
2228       if ( !( *it )->text(1).isEmpty() ) out << ": " << ( *it )->text(1);
2229       out << "\n";
2230     }
2231     ++it;
2232   }
2233   out << "\n";
2234 }
2235
2236 /*!
2237   \class GrpComputor
2238   \brief Mesh information computer
2239   \internal
2240   
2241   The class is created for different computation operation. Currently it is used
2242   to compute number of underlying nodes for the groups.
2243 */
2244
2245 /*!
2246   \brief Contructor
2247 */
2248 GrpComputor::GrpComputor( SMESH::SMESH_GroupBase_ptr grp, QTreeWidgetItem* item, QObject* parent )
2249   : QObject( parent ), myItem( item )
2250 {
2251   myGroup = SMESH::SMESH_GroupBase::_narrow( grp );
2252 }
2253
2254 /*!
2255   \brief Compute function
2256 */
2257 void GrpComputor::compute()
2258 {
2259   if ( !CORBA::is_nil( myGroup ) && myItem ) {
2260     QTreeWidgetItem* item = myItem;
2261     myItem = 0;
2262     int nbNodes = myGroup->GetNumberOfNodes();
2263     item->treeWidget()->removeItemWidget( item, 1 );
2264     item->setText( 1, QString::number( nbNodes ));
2265   }
2266 }
2267
2268 /*!
2269   \class SMESHGUI_AddInfo
2270   \brief The wigdet shows additional information on the mesh object.
2271 */
2272
2273 /*!
2274   \brief Constructor
2275   \param parent parent widget
2276 */
2277 SMESHGUI_AddInfo::SMESHGUI_AddInfo( QWidget* parent )
2278 : QTreeWidget( parent )
2279 {
2280   setColumnCount( 2 );
2281   header()->setStretchLastSection( true );
2282   header()->setResizeMode( 0, QHeaderView::ResizeToContents );
2283   header()->hide();
2284 }
2285
2286 /*!
2287   \brief Destructor
2288 */
2289 SMESHGUI_AddInfo::~SMESHGUI_AddInfo()
2290 {
2291 }
2292
2293 /*!
2294   \brief Show additional information on the selected object
2295   \param obj object being processed (mesh, sub-mesh, group, ID source)
2296 */
2297 void SMESHGUI_AddInfo::showInfo( SMESH::SMESH_IDSource_ptr obj )
2298 {
2299   setProperty( "group_index", 0 );
2300   setProperty( "submesh_index",  0 );
2301   myComputors.clear();
2302   clear();
2303
2304   if ( CORBA::is_nil( obj ) ) return;
2305
2306   _PTR(SObject) sobj = SMESH::ObjectToSObject( obj );
2307   if ( !sobj ) return;
2308
2309   // name
2310   QTreeWidgetItem* nameItem = createItem( 0, Bold | All );
2311   nameItem->setText( 0, tr( "NAME" ) );
2312   nameItem->setText( 1, sobj->GetName().c_str() );
2313   
2314   SMESH::SMESH_Mesh_var      aMesh    = SMESH::SMESH_Mesh::_narrow( obj );
2315   SMESH::SMESH_subMesh_var   aSubMesh = SMESH::SMESH_subMesh::_narrow( obj );
2316   SMESH::SMESH_GroupBase_var aGroup   = SMESH::SMESH_GroupBase::_narrow( obj );
2317   
2318   if ( !aMesh->_is_nil() )
2319     meshInfo( aMesh, nameItem );
2320   else if ( !aSubMesh->_is_nil() )
2321     subMeshInfo( aSubMesh, nameItem );
2322   else if ( !aGroup->_is_nil() )
2323     groupInfo( aGroup.in(), nameItem );
2324 }
2325
2326 /*!
2327   \brief Create new tree item.
2328   \param parent parent tree widget item
2329   \param flags item flag
2330   \return new tree widget item
2331 */
2332 QTreeWidgetItem* SMESHGUI_AddInfo::createItem( QTreeWidgetItem* parent, int flags )
2333 {
2334   QTreeWidgetItem* item;
2335
2336   if ( parent )
2337     item = new QTreeWidgetItem( parent );
2338   else
2339     item = new QTreeWidgetItem( this );
2340
2341   //item->setFlags( item->flags() | Qt::ItemIsEditable );
2342
2343   QFont f = item->font( 0 );
2344   f.setBold( true );
2345   for ( int i = 0; i < columnCount(); i++ ) {
2346     if ( ( flags & Bold ) && ( i == 0 || flags & All ) )
2347       item->setFont( i, f );
2348   }
2349
2350   item->setExpanded( true );
2351   return item;
2352 }
2353
2354 /*!
2355   \brief Show mesh info
2356   \param mesh mesh object
2357   \param parent parent tree item
2358 */
2359 void SMESHGUI_AddInfo::meshInfo( SMESH::SMESH_Mesh_ptr mesh, QTreeWidgetItem* parent )
2360 {
2361   // type
2362   GEOM::GEOM_Object_var shape = mesh->GetShapeToMesh();
2363   SMESH::MedFileInfo_var inf = mesh->GetMEDFileInfo();
2364   QTreeWidgetItem* typeItem = createItem( parent, Bold );
2365   typeItem->setText( 0, tr( "TYPE" ) );
2366   if ( !CORBA::is_nil( shape ) ) {
2367     typeItem->setText( 1, tr( "MESH_ON_GEOMETRY" ) );
2368     _PTR(SObject) sobj = SMESH::ObjectToSObject( shape );
2369     if ( sobj ) {
2370       QTreeWidgetItem* gobjItem = createItem( typeItem );
2371       gobjItem->setText( 0, tr( "GEOM_OBJECT" ) );
2372       gobjItem->setText( 1, sobj->GetName().c_str() );
2373     }
2374   }
2375   else if ( strlen( (char*)inf->fileName ) > 0 ) {
2376     typeItem->setText( 1, tr( "MESH_FROM_FILE" ) );
2377     QTreeWidgetItem* fileItem = createItem( typeItem );
2378     fileItem->setText( 0, tr( "FILE_NAME" ) );
2379     fileItem->setText( 1, (char*)inf->fileName );
2380   }
2381   else {
2382     typeItem->setText( 1, tr( "STANDALONE_MESH" ) );
2383   }
2384   
2385   // groups
2386   myGroups = mesh->GetGroups();
2387   showGroups();
2388
2389   // sub-meshes
2390   mySubMeshes = mesh->GetSubMeshes();
2391   showSubMeshes();
2392 }
2393
2394 /*!
2395   \brief Show sub-mesh info
2396   \param subMesh sub-mesh object
2397   \param parent parent tree item
2398 */
2399 void SMESHGUI_AddInfo::subMeshInfo( SMESH::SMESH_subMesh_ptr subMesh, QTreeWidgetItem* parent )
2400 {
2401   bool isShort = parent->parent() != 0;
2402
2403   if ( !isShort ) {
2404     // parent mesh
2405     _PTR(SObject) sobj = SMESH::ObjectToSObject( subMesh->GetFather() );
2406     if ( sobj ) {
2407       QTreeWidgetItem* nameItem = createItem( parent, Bold );
2408       nameItem->setText( 0, tr( "PARENT_MESH" ) );
2409       nameItem->setText( 1, sobj->GetName().c_str() );
2410     }
2411   }
2412   
2413   // shape
2414   GEOM::GEOM_Object_var gobj = subMesh->GetSubShape();
2415   _PTR(SObject) sobj = SMESH::ObjectToSObject( gobj );
2416   if ( sobj ) {
2417     QTreeWidgetItem* gobjItem = createItem( parent, Bold );
2418     gobjItem->setText( 0, tr( "GEOM_OBJECT" ) );
2419     gobjItem->setText( 1, sobj->GetName().c_str() );
2420   }
2421 }
2422
2423 /*!
2424   \brief Show group info
2425   \param grp mesh group object
2426   \param parent parent tree item
2427 */
2428 void SMESHGUI_AddInfo::groupInfo( SMESH::SMESH_GroupBase_ptr grp, QTreeWidgetItem* parent )
2429 {
2430   bool isShort = parent->parent() != 0;
2431
2432   SMESH::SMESH_Group_var         aStdGroup  = SMESH::SMESH_Group::_narrow( grp );
2433   SMESH::SMESH_GroupOnGeom_var   aGeomGroup = SMESH::SMESH_GroupOnGeom::_narrow( grp );
2434   SMESH::SMESH_GroupOnFilter_var aFltGroup  = SMESH::SMESH_GroupOnFilter::_narrow( grp );
2435
2436   if ( !isShort ) {
2437     // parent mesh
2438     _PTR(SObject) sobj = SMESH::ObjectToSObject( grp->GetMesh() );
2439     if ( sobj ) {
2440       QTreeWidgetItem* nameItem = createItem( parent, Bold );
2441       nameItem->setText( 0, tr( "PARENT_MESH" ) );
2442       nameItem->setText( 1, sobj->GetName().c_str() );
2443     }
2444   }
2445
2446   // type : group on geometry, standalone group, group on filter
2447   QTreeWidgetItem* typeItem = createItem( parent, Bold );
2448   typeItem->setText( 0, tr( "TYPE" ) );
2449   if ( !CORBA::is_nil( aStdGroup ) ) {
2450     typeItem->setText( 1, tr( "STANDALONE_GROUP" ) );
2451   }
2452   else if ( !CORBA::is_nil( aGeomGroup ) ) {
2453     typeItem->setText( 1, tr( "GROUP_ON_GEOMETRY" ) );
2454     GEOM::GEOM_Object_var gobj = aGeomGroup->GetShape();
2455     _PTR(SObject) sobj = SMESH::ObjectToSObject( gobj );
2456     if ( sobj ) {
2457       QTreeWidgetItem* gobjItem = createItem( typeItem );
2458       gobjItem->setText( 0, tr( "GEOM_OBJECT" ) );
2459       gobjItem->setText( 1, sobj->GetName().c_str() );
2460     }
2461   }
2462   else if ( !CORBA::is_nil( aFltGroup ) ) {
2463     typeItem->setText( 1, tr( "GROUP_ON_FILTER" ) );
2464   }
2465
2466   if ( !isShort ) {
2467     // entity type
2468     QString etype = tr( "UNKNOWN" );
2469     switch( grp->GetType() ) {
2470     case SMESH::NODE:
2471       etype = tr( "NODE" );
2472       break;
2473     case SMESH::EDGE:
2474       etype = tr( "EDGE" );
2475       break;
2476     case SMESH::FACE:
2477       etype = tr( "FACE" );
2478       break;
2479     case SMESH::VOLUME:
2480       etype = tr( "VOLUME" );
2481       break;
2482     case SMESH::ELEM0D:
2483       etype = tr( "0DELEM" );
2484       break;
2485     case SMESH::BALL:
2486       etype = tr( "BALL" );
2487       break;
2488     default:
2489       break;
2490     }
2491     QTreeWidgetItem* etypeItem = createItem( parent, Bold );
2492     etypeItem->setText( 0, tr( "ENTITY_TYPE" ) );
2493     etypeItem->setText( 1, etype );
2494   }
2495
2496   // size
2497   QTreeWidgetItem* sizeItem = createItem( parent, Bold );
2498   sizeItem->setText( 0, tr( "SIZE" ) );
2499   sizeItem->setText( 1, QString::number( grp->Size() ) );
2500
2501   // color
2502   SALOMEDS::Color color = grp->GetColor();
2503   QTreeWidgetItem* colorItem = createItem( parent, Bold );
2504   colorItem->setText( 0, tr( "COLOR" ) );
2505   colorItem->setBackground( 1, QBrush( QColor( color.R*255., color.G*255., color.B*255.) ) );
2506
2507   // nb of underlying nodes
2508   if ( grp->GetType() != SMESH::NODE) {
2509     QTreeWidgetItem* nodesItem = createItem( parent, Bold );
2510     nodesItem->setText( 0, tr( "NB_NODES" ) );
2511     int nbNodesLimit = SMESHGUI::resourceMgr()->integerValue( "SMESH", "info_groups_nodes_limit", 100000 );
2512     SMESH::SMESH_Mesh_var mesh = grp->GetMesh();
2513     bool meshLoaded = mesh->IsLoaded();
2514     bool toShowNodes = ( grp->IsNodeInfoAvailable() || nbNodesLimit <= 0 || grp->Size() <= nbNodesLimit );
2515     if ( toShowNodes && meshLoaded ) {
2516       // already calculated and up-to-date
2517       nodesItem->setText( 1, QString::number( grp->GetNumberOfNodes() ) );
2518     }
2519     else {
2520       QPushButton* btn = new QPushButton( tr( meshLoaded ? "COMPUTE" : "LOAD"), this );
2521       setItemWidget( nodesItem, 1, btn );
2522       GrpComputor* comp = new GrpComputor( grp, nodesItem, this ); 
2523       connect( btn, SIGNAL( clicked() ), comp, SLOT( compute() ) );
2524       myComputors.append( comp );
2525       if ( !meshLoaded )
2526         connect( btn, SIGNAL( clicked() ), this, SLOT( changeLoadToCompute() ) );
2527     }
2528   }
2529 }
2530
2531 void SMESHGUI_AddInfo::showGroups()
2532 {
2533   myComputors.clear();
2534
2535   QTreeWidgetItem* parent = topLevelItemCount() > 0 ? topLevelItem( 0 ) : 0; // parent should be first top level item
2536   if ( !parent ) return;
2537
2538   int idx = property( "group_index" ).toInt();
2539
2540   QTreeWidgetItem* itemGroups = 0;
2541   for ( int i = 0; i < parent->childCount() && !itemGroups; i++ ) {
2542     if ( parent->child( i )->data( 0, Qt::UserRole ).toInt() == GROUPS_ID ) {
2543       itemGroups = parent->child( i );
2544       ExtraWidget* extra = dynamic_cast<ExtraWidget*>( itemWidget( itemGroups, 1 ) );
2545       if ( extra )
2546         extra->updateControls( myGroups->length(), idx );
2547       while ( itemGroups->childCount() ) delete itemGroups->child( 0 ); // clear child items
2548     }
2549   }
2550
2551   QMap<int, QTreeWidgetItem*> grpItems;
2552   for ( int i = idx*MAXITEMS ; i < qMin( (idx+1)*MAXITEMS, (int)myGroups->length() ); i++ ) {
2553     SMESH::SMESH_GroupBase_var grp = myGroups[i];
2554     if ( CORBA::is_nil( grp ) ) continue;
2555     _PTR(SObject) grpSObj = SMESH::ObjectToSObject( grp );
2556     if ( !grpSObj ) continue;
2557
2558     int grpType = grp->GetType();
2559
2560     if ( !itemGroups ) {
2561       // create top-level groups container item
2562       itemGroups = createItem( parent, Bold | All );
2563       itemGroups->setText( 0, tr( "GROUPS" ) );
2564       itemGroups->setData( 0, Qt::UserRole, GROUPS_ID );
2565
2566       // total number of groups > 10, show extra widgets for info browsing
2567       if ( myGroups->length() > MAXITEMS ) {
2568         ExtraWidget* extra = new ExtraWidget( this, true );
2569         connect( extra->prev, SIGNAL( clicked() ), this, SLOT( showPreviousGroups() ) );
2570         connect( extra->next, SIGNAL( clicked() ), this, SLOT( showNextGroups() ) );
2571         setItemWidget( itemGroups, 1, extra );
2572         extra->updateControls( myGroups->length(), idx );
2573       }
2574     }
2575
2576     if ( grpItems.find( grpType ) == grpItems.end() ) {
2577       grpItems[ grpType ] = createItem( itemGroups, Bold | All );
2578       grpItems[ grpType ]->setText( 0, tr( QString( "GROUPS_%1" ).arg( grpType ).toLatin1().constData() ) );
2579       itemGroups->insertChild( grpType-1, grpItems[ grpType ] );
2580     }
2581   
2582     // group name
2583     QTreeWidgetItem* grpNameItem = createItem( grpItems[ grpType ] );
2584     grpNameItem->setText( 0, QString( grpSObj->GetName().c_str() ).trimmed() ); // name is trimmed
2585
2586     // group info
2587     groupInfo( grp.in(), grpNameItem );
2588   }
2589 }
2590
2591 void SMESHGUI_AddInfo::showSubMeshes()
2592 {
2593   QTreeWidgetItem* parent = topLevelItemCount() > 0 ? topLevelItem( 0 ) : 0; // parent should be first top level item
2594   if ( !parent ) return;
2595
2596   int idx = property( "submesh_index" ).toInt();
2597
2598   QTreeWidgetItem* itemSubMeshes = 0;
2599   for ( int i = 0; i < parent->childCount() && !itemSubMeshes; i++ ) {
2600     if ( parent->child( i )->data( 0, Qt::UserRole ).toInt() == SUBMESHES_ID ) {
2601       itemSubMeshes = parent->child( i );
2602       ExtraWidget* extra = dynamic_cast<ExtraWidget*>( itemWidget( itemSubMeshes, 1 ) );
2603       if ( extra )
2604         extra->updateControls( mySubMeshes->length(), idx );
2605       while ( itemSubMeshes->childCount() ) delete itemSubMeshes->child( 0 ); // clear child items
2606     }
2607   }
2608
2609   QMap<int, QTreeWidgetItem*> smItems;
2610   for ( int i = idx*MAXITEMS ; i < qMin( (idx+1)*MAXITEMS, (int)mySubMeshes->length() ); i++ ) {
2611     SMESH::SMESH_subMesh_var sm = mySubMeshes[i];
2612     if ( CORBA::is_nil( sm ) ) continue;
2613     _PTR(SObject) smSObj = SMESH::ObjectToSObject( sm );
2614     if ( !smSObj ) continue;
2615     
2616     GEOM::GEOM_Object_var gobj = sm->GetSubShape();
2617     if ( CORBA::is_nil(gobj ) ) continue;
2618     
2619     int smType = gobj->GetShapeType();
2620     if ( smType == GEOM::COMPSOLID ) smType = GEOM::COMPOUND;
2621
2622     if ( !itemSubMeshes ) {
2623       itemSubMeshes = createItem( parent, Bold | All );
2624       itemSubMeshes->setText( 0, tr( "SUBMESHES" ) );
2625       itemSubMeshes->setData( 0, Qt::UserRole, SUBMESHES_ID );
2626
2627       // total number of sub-meshes > 10, show extra widgets for info browsing
2628       if ( mySubMeshes->length() > MAXITEMS ) {
2629         ExtraWidget* extra = new ExtraWidget( this, true );
2630         connect( extra->prev, SIGNAL( clicked() ), this, SLOT( showPreviousSubMeshes() ) );
2631         connect( extra->next, SIGNAL( clicked() ), this, SLOT( showNextSubMeshes() ) );
2632         setItemWidget( itemSubMeshes, 1, extra );
2633         extra->updateControls( mySubMeshes->length(), idx );
2634       }
2635     }
2636          
2637     if ( smItems.find( smType ) == smItems.end() ) {
2638       smItems[ smType ] = createItem( itemSubMeshes, Bold | All );
2639       smItems[ smType ]->setText( 0, tr( QString( "SUBMESHES_%1" ).arg( smType ).toLatin1().constData() ) );
2640       itemSubMeshes->insertChild( smType, smItems[ smType ] );
2641     }
2642     
2643     // submesh name
2644     QTreeWidgetItem* smNameItem = createItem( smItems[ smType ] );
2645     smNameItem->setText( 0, QString( smSObj->GetName().c_str() ).trimmed() ); // name is trimmed
2646     
2647     // submesh info
2648     subMeshInfo( sm.in(), smNameItem );
2649   }
2650 }
2651
2652 /*!
2653  * \brief Change button label of "nb underlying node" group from "Load" to "Compute"
2654  */
2655 void SMESHGUI_AddInfo::changeLoadToCompute()
2656 {
2657   for ( int i = 0; i < myComputors.count(); ++i )
2658   {
2659     if ( QTreeWidgetItem* item = myComputors[i]->getItem() )
2660     {
2661       if ( QPushButton* btn = qobject_cast<QPushButton*>( itemWidget ( item, 1 ) ) )
2662         btn->setText( tr("COMPUTE") );
2663     }
2664   }
2665 }
2666
2667 void SMESHGUI_AddInfo::showPreviousGroups()
2668 {
2669   int idx = property( "group_index" ).toInt();
2670   setProperty( "group_index", idx-1 );
2671   showGroups();
2672 }
2673
2674 void SMESHGUI_AddInfo::showNextGroups()
2675 {
2676   int idx = property( "group_index" ).toInt();
2677   setProperty( "group_index", idx+1 );
2678   showGroups();
2679 }
2680
2681 void SMESHGUI_AddInfo::showPreviousSubMeshes()
2682 {
2683   int idx = property( "submesh_index" ).toInt();
2684   setProperty( "submesh_index", idx-1 );
2685   showSubMeshes();
2686 }
2687
2688 void SMESHGUI_AddInfo::showNextSubMeshes()
2689 {
2690   int idx = property( "submesh_index" ).toInt();
2691   setProperty( "submesh_index", idx+1 );
2692   showSubMeshes();
2693 }
2694
2695 void SMESHGUI_AddInfo::saveInfo( QTextStream &out )
2696 {
2697   out << QString( 15, '-')       << "\n";
2698   out << tr( "ADDITIONAL_INFO" ) << "\n";
2699   out << QString( 15, '-' )      << "\n";
2700   QTreeWidgetItemIterator it( this );
2701   while ( *it ) {
2702     if ( !( ( *it )->text(0) ).isEmpty() ) {
2703       out << QString( SPACING_INFO * itemDepth( *it ), ' ' ) << ( *it )->text(0);
2704       if ( ( *it )->text(0)  == tr( "COLOR" ) ) {
2705         out << ": " << ( ( ( *it )->background(1) ).color() ).name();
2706       }
2707       else if ( !( ( *it )->text(1) ).isEmpty() ) out << ": " << ( *it )->text(1);
2708       out << "\n";
2709     }
2710     ++it;
2711   }
2712   out << "\n";
2713 }
2714
2715 /*!
2716   \class SMESHGUI_MeshInfoDlg
2717   \brief Mesh information dialog box
2718 */
2719
2720 /*!
2721   \brief Constructor
2722   \param parent parent widget
2723   \param page specifies the dialog page to be shown at the start-up
2724 */
2725 SMESHGUI_MeshInfoDlg::SMESHGUI_MeshInfoDlg( QWidget* parent, int page )
2726 : QDialog( parent ), myActor( 0 )
2727 {
2728   setModal( false );
2729   setAttribute( Qt::WA_DeleteOnClose, true );
2730   setWindowTitle( tr( "MESH_INFO" ) );
2731   setSizeGripEnabled( true );
2732
2733   myTabWidget = new QTabWidget( this );
2734
2735   // base info 
2736
2737   myBaseInfo = new SMESHGUI_MeshInfo( myTabWidget );
2738   myTabWidget->addTab( myBaseInfo, tr( "BASE_INFO" ) );
2739
2740   // elem info 
2741   
2742   QWidget* w = new QWidget( myTabWidget );
2743
2744   myMode = new QButtonGroup( this );
2745   myMode->addButton( new QRadioButton( tr( "NODE_MODE" ), w ), NodeMode );
2746   myMode->addButton( new QRadioButton( tr( "ELEM_MODE" ), w ), ElemMode );
2747   myMode->button( NodeMode )->setChecked( true );
2748   myID = new QLineEdit( w );
2749   myID->setValidator( new SMESHGUI_IdValidator( this ) );
2750
2751   int mode = SMESHGUI::resourceMgr()->integerValue( "SMESH", "mesh_elem_info", 1 );
2752   mode = qMin( 1, qMax( 0, mode ) );
2753   
2754   if ( mode == 0 ) 
2755     myElemInfo = new SMESHGUI_SimpleElemInfo( w );
2756   else
2757     myElemInfo = new SMESHGUI_TreeElemInfo( w );
2758
2759   QGridLayout* elemLayout = new QGridLayout( w );
2760   elemLayout->setMargin( MARGIN );
2761   elemLayout->setSpacing( SPACING );
2762   elemLayout->addWidget( myMode->button( NodeMode ), 0, 0 );
2763   elemLayout->addWidget( myMode->button( ElemMode ), 0, 1 );
2764   elemLayout->addWidget( myID, 0, 2 );
2765   elemLayout->addWidget( myElemInfo, 1, 0, 1, 3 );
2766   
2767   myTabWidget->addTab( w, tr( "ELEM_INFO" ) );
2768
2769   // additional info
2770
2771   myAddInfo = new SMESHGUI_AddInfo( myTabWidget );
2772   myTabWidget->addTab( myAddInfo, tr( "ADDITIONAL_INFO" ) );
2773
2774   // controls info
2775
2776   myCtrlInfo = new SMESHGUI_CtrlInfo( myTabWidget );
2777   myTabWidget->addTab( myCtrlInfo, tr( "CTRL_INFO" ) );
2778
2779   // buttons
2780
2781   QPushButton* okBtn = new QPushButton( tr( "SMESH_BUT_OK" ), this );
2782   okBtn->setAutoDefault( true );
2783   okBtn->setDefault( true );
2784   okBtn->setFocus();
2785   QPushButton* dumpBtn = new QPushButton( tr( "BUT_DUMP_MESH" ), this );
2786   dumpBtn->setAutoDefault( true );
2787   QPushButton* helpBtn = new QPushButton( tr( "SMESH_BUT_HELP" ), this );
2788   helpBtn->setAutoDefault( true );
2789
2790   QHBoxLayout* btnLayout = new QHBoxLayout;
2791   btnLayout->setSpacing( SPACING );
2792   btnLayout->setMargin( 0 );
2793
2794   btnLayout->addWidget( okBtn );
2795   btnLayout->addWidget( dumpBtn );
2796   btnLayout->addStretch( 10 );
2797   btnLayout->addWidget( helpBtn );
2798
2799   QVBoxLayout* l = new QVBoxLayout ( this );
2800   l->setMargin( MARGIN );
2801   l->setSpacing( SPACING );
2802   l->addWidget( myTabWidget );
2803   l->addLayout( btnLayout );
2804
2805   myTabWidget->setCurrentIndex( qMax( (int)BaseInfo, qMin( (int)ElemInfo, page ) ) );
2806
2807   connect( okBtn,       SIGNAL( clicked() ),              this, SLOT( reject() ) );
2808   connect( dumpBtn,     SIGNAL( clicked() ),              this, SLOT( dump() ) );
2809   connect( helpBtn,     SIGNAL( clicked() ),              this, SLOT( help() ) );
2810   connect( myTabWidget, SIGNAL( currentChanged( int  ) ), this, SLOT( updateSelection() ) );
2811   connect( myMode,      SIGNAL( buttonClicked( int  ) ),  this, SLOT( modeChanged() ) );
2812   connect( myID,        SIGNAL( textChanged( QString ) ), this, SLOT( idChanged() ) );
2813   connect( SMESHGUI::GetSMESHGUI(),  SIGNAL( SignalDeactivateActiveDialog() ), this, SLOT( deactivate() ) );
2814   connect( SMESHGUI::GetSMESHGUI(),  SIGNAL( SignalCloseAllDialogs() ),        this, SLOT( reject() ) );
2815   connect( myElemInfo,  SIGNAL( itemInfo( int ) ),     this, SLOT( showItemInfo( int ) ) );
2816   connect( myElemInfo,  SIGNAL( itemInfo( QString ) ), this, SLOT( showItemInfo( QString ) ) );
2817
2818   updateSelection();
2819 }
2820
2821 /*!
2822   \brief Destructor
2823 */
2824 SMESHGUI_MeshInfoDlg::~SMESHGUI_MeshInfoDlg()
2825 {
2826 }
2827
2828 /*!
2829   \brief Show mesh information
2830   \param IO interactive object
2831 */
2832 void SMESHGUI_MeshInfoDlg::showInfo( const Handle(SALOME_InteractiveObject)& IO )
2833 {
2834   SMESH::SMESH_IDSource_var obj = SMESH::IObjectToInterface<SMESH::SMESH_IDSource>( IO );
2835   if ( !CORBA::is_nil( obj ) ) {
2836     myBaseInfo->showInfo( obj );
2837     myAddInfo->showInfo( obj );
2838     myCtrlInfo->showInfo( obj );
2839
2840     myActor = SMESH::FindActorByEntry( IO->getEntry() );
2841     SVTK_Selector* selector = SMESH::GetViewWindow()->GetSelector();
2842     QString ID;
2843     int nb = 0;
2844     if ( myActor && selector ) {
2845       nb = myMode->checkedId() == NodeMode ? 
2846         SMESH::GetNameOfSelectedElements( selector, IO, ID ) :
2847         SMESH::GetNameOfSelectedNodes( selector, IO, ID );
2848     }
2849     myElemInfo->setSource( myActor ) ;
2850     if ( nb > 0 ) {
2851       myID->setText( ID.trimmed() );
2852       QSet<long> ids;
2853       QStringList idTxt = ID.split( " ", QString::SkipEmptyParts );
2854       foreach ( ID, idTxt )
2855         ids << ID.trimmed().toLong();
2856       myElemInfo->showInfo( ids, myMode->checkedId() == ElemMode );
2857     }
2858     else {
2859       myID->clear();
2860       myElemInfo->clear();
2861     }
2862   }
2863 }
2864
2865 /*!
2866   \brief Perform clean-up actions on the dialog box closing.
2867 */
2868 void SMESHGUI_MeshInfoDlg::reject()
2869 {
2870   LightApp_SelectionMgr* selMgr = SMESHGUI::selectionMgr();
2871   selMgr->clearFilters();
2872   SMESH::SetPointRepresentation( false );
2873   if ( SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow() )