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