Salome HOME
23416: [CEA 2033] Impossible to re-compute a mesh from an hdf
[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   connect( myInfo, SIGNAL( itemCollapsed( QTreeWidgetItem* )), this, SLOT( saveExpanded( QTreeWidgetItem* )) );
1665   connect( myInfo, SIGNAL( itemExpanded( QTreeWidgetItem* )), this, SLOT( saveExpanded( QTreeWidgetItem* )) );
1666 }
1667
1668 /*!
1669   \brief Show mesh element information
1670   \param ids mesh nodes / elements identifiers
1671 */
1672 void SMESHGUI_TreeElemInfo::information( const QList<long>& ids )
1673 {
1674   clearInternal();
1675
1676   if ( actor() ) {
1677     int grp_details = SMESHGUI::resourceMgr()->booleanValue( "SMESH", "elem_info_grp_details", false );
1678     int precision   = SMESHGUI::resourceMgr()->integerValue( "SMESH", "length_precision", 6 );
1679     int cprecision = -1;
1680     if ( SMESHGUI::resourceMgr()->booleanValue( "SMESH", "use_precision", false )) 
1681       cprecision = SMESHGUI::resourceMgr()->integerValue( "SMESH", "controls_precision", -1 );
1682     foreach ( long id, ids ) {
1683       if ( !isElements() ) {
1684         //
1685         // show node info
1686         //
1687         const SMDS_MeshElement* e = actor()->GetObject()->GetMesh()->FindNode( id );
1688         if ( !e ) return;
1689         const SMDS_MeshNode* node = static_cast<const SMDS_MeshNode*>( e );
1690       
1691         // node ID
1692         QTreeWidgetItem* nodeItem = createItem( 0, Bold | All );
1693         nodeItem->setText( 0, SMESHGUI_ElemInfo::tr( "NODE" ));
1694         nodeItem->setText( 1, QString( "#%1" ).arg( id ));
1695         // coordinates
1696         QTreeWidgetItem* coordItem = createItem( nodeItem, Bold );
1697         coordItem->setText( 0, SMESHGUI_ElemInfo::tr( "COORDINATES" ));
1698         QTreeWidgetItem* xItem = createItem( coordItem );
1699         xItem->setText( 0, "X" );
1700         xItem->setText( 1, QString::number( node->X(), precision > 0 ? 'f' : 'g', qAbs( precision )) );
1701         QTreeWidgetItem* yItem = createItem( coordItem );
1702         yItem->setText( 0, "Y" );
1703         yItem->setText( 1, QString::number( node->Y(), precision > 0 ? 'f' : 'g', qAbs( precision )) );
1704         QTreeWidgetItem* zItem = createItem( coordItem );
1705         zItem->setText( 0, "Z" );
1706         zItem->setText( 1, QString::number( node->Z(), precision > 0 ? 'f' : 'g', qAbs( precision )) );
1707         // connectivity
1708         QTreeWidgetItem* conItem = createItem( nodeItem, Bold );
1709         conItem->setText( 0, SMESHGUI_ElemInfo::tr( "CONNECTIVITY" ));
1710         Connectivity connectivity = nodeConnectivity( node );
1711         if ( !connectivity.isEmpty() ) {
1712           QString con = formatConnectivity( connectivity, SMDSAbs_0DElement );
1713           if ( !con.isEmpty() ) {
1714             QTreeWidgetItem* i = createItem( conItem );
1715             i->setText( 0, SMESHGUI_ElemInfo::tr( "0D_ELEMENTS" ));
1716             i->setText( 1, con );
1717           }
1718           con = formatConnectivity( connectivity, SMDSAbs_Ball );
1719           if ( !con.isEmpty() ) {
1720             QTreeWidgetItem* i = createItem( conItem );
1721             i->setText( 0, SMESHGUI_ElemInfo::tr( "BALL_ELEMENTS" ));
1722             i->setText( 1, con );
1723             i->setData( 1, TypeRole, NodeConnectivity );
1724           }
1725           con = formatConnectivity( connectivity, SMDSAbs_Edge );
1726           if ( !con.isEmpty() ) {
1727             QTreeWidgetItem* i = createItem( conItem );
1728             i->setText( 0, SMESHGUI_ElemInfo::tr( "EDGES" ));
1729             i->setText( 1, con );
1730             i->setData( 1, TypeRole, NodeConnectivity );
1731           }
1732           con = formatConnectivity( connectivity, SMDSAbs_Face );
1733           if ( !con.isEmpty() ) {
1734             QTreeWidgetItem* i = createItem( conItem );
1735             i->setText( 0, SMESHGUI_ElemInfo::tr( "FACES" ));
1736             i->setText( 1, con );
1737             i->setData( 1, TypeRole, NodeConnectivity );
1738           }
1739           con = formatConnectivity( connectivity, SMDSAbs_Volume );
1740           if ( !con.isEmpty() ) {
1741             QTreeWidgetItem* i = createItem( conItem );
1742             i->setText( 0, SMESHGUI_ElemInfo::tr( "VOLUMES" ));
1743             i->setText( 1, con );
1744             i->setData( 1, TypeRole, NodeConnectivity );
1745           }
1746         }
1747         else {
1748           conItem->setText( 1, SMESHGUI_ElemInfo::tr( "FREE_NODE" ));
1749         }
1750         // node position
1751         SMESH::SMESH_Mesh_ptr aMeshPtr = actor()->GetObject()->GetMeshServer();   
1752         if ( !CORBA::is_nil( aMeshPtr )) {
1753           SMESH::NodePosition_var pos = aMeshPtr->GetNodePosition( id );
1754           int shapeID = pos->shapeID;
1755           if ( shapeID > 0 ) {
1756             QString shapeType;
1757             double u = 0, v = 0;
1758             switch ( pos->shapeType ) {
1759             case GEOM::EDGE:
1760               shapeType = SMESHGUI_ElemInfo::tr( "GEOM_EDGE" );
1761               if ( pos->params.length() == 1 )
1762                 u = pos->params[0];
1763               break;
1764             case GEOM::FACE:
1765               shapeType = SMESHGUI_ElemInfo::tr( "GEOM_FACE" );
1766               if ( pos->params.length() == 2 ) {
1767                 u = pos->params[0];
1768                 v = pos->params[1];
1769               }
1770               break;
1771             case GEOM::VERTEX:
1772               shapeType = SMESHGUI_ElemInfo::tr( "GEOM_VERTEX" );
1773               break;
1774             default:
1775               shapeType = SMESHGUI_ElemInfo::tr( "GEOM_SOLID" );
1776               break;
1777             }
1778             QTreeWidgetItem* posItem = createItem( nodeItem, Bold );
1779             posItem->setText( 0, SMESHGUI_ElemInfo::tr("POSITION") );
1780             posItem->setText( 1, (shapeType + " #%1").arg( shapeID ));
1781             if ( pos->shapeType == GEOM::EDGE || pos->shapeType == GEOM::FACE ) {
1782               QTreeWidgetItem* uItem = createItem( posItem );
1783               uItem->setText( 0, SMESHGUI_ElemInfo::tr("U_POSITION") );
1784               uItem->setText( 1, QString::number( u, precision > 0 ? 'f' : 'g', qAbs( precision )));
1785               if ( pos->shapeType == GEOM::FACE ) {
1786                 QTreeWidgetItem* vItem = createItem( posItem );
1787                 vItem->setText( 0, SMESHGUI_ElemInfo::tr("V_POSITION") );
1788                 vItem->setText( 1, QString::number( v, precision > 0 ? 'f' : 'g', qAbs( precision )));
1789               }
1790             }
1791           }
1792         }
1793         // groups node belongs to
1794         SMESH::SMESH_Mesh_ptr aMesh = actor()->GetObject()->GetMeshServer();
1795         if ( !CORBA::is_nil( aMesh )) {
1796           SMESH::ListOfGroups_var groups = aMesh->GetGroups();
1797           QTreeWidgetItem* groupsItem = 0;
1798           for ( CORBA::ULong i = 0; i < groups->length(); i++ ) {
1799             SMESH::SMESH_GroupBase_var aGrp = groups[i];
1800             if ( CORBA::is_nil( aGrp )) continue;
1801             QString aName = aGrp->GetName();
1802             if ( aGrp->GetType() == SMESH::NODE && !aName.isEmpty() && aGrp->Contains( id )) {
1803               if ( !groupsItem ) {
1804                 groupsItem = createItem( nodeItem, Bold );
1805                 groupsItem->setText( 0, SMESHGUI_AddInfo::tr( "GROUPS" ));
1806               }
1807               QTreeWidgetItem* it = createItem( groupsItem, Bold );
1808               it->setText( 0, aName.trimmed() );
1809               if ( grp_details ) {
1810                 SMESH::SMESH_Group_var         aStdGroup  = SMESH::SMESH_Group::_narrow( aGrp );
1811                 SMESH::SMESH_GroupOnGeom_var   aGeomGroup = SMESH::SMESH_GroupOnGeom::_narrow( aGrp );
1812                 SMESH::SMESH_GroupOnFilter_var aFltGroup  = SMESH::SMESH_GroupOnFilter::_narrow( aGrp );
1813                 
1814                 // type : group on geometry, standalone group, group on filter
1815                 QTreeWidgetItem* typeItem = createItem( it );
1816                 typeItem->setText( 0, SMESHGUI_AddInfo::tr( "TYPE" ));
1817                 if ( !CORBA::is_nil( aStdGroup )) {
1818                   typeItem->setText( 1, SMESHGUI_AddInfo::tr( "STANDALONE_GROUP" ));
1819                 }
1820                 else if ( !CORBA::is_nil( aGeomGroup )) {
1821                   typeItem->setText( 1, SMESHGUI_AddInfo::tr( "GROUP_ON_GEOMETRY" ));
1822                   GEOM::GEOM_Object_var gobj = aGeomGroup->GetShape();
1823                   _PTR(SObject) sobj = SMESH::ObjectToSObject( gobj );
1824                   if ( sobj ) {
1825                     QTreeWidgetItem* gobjItem = createItem( typeItem );
1826                     gobjItem->setText( 0, SMESHGUI_AddInfo::tr( "GEOM_OBJECT" ));
1827                     gobjItem->setText( 1, sobj->GetName().c_str() );
1828                   }
1829                 }
1830                 else if ( !CORBA::is_nil( aFltGroup )) {
1831                   typeItem->setText( 1, SMESHGUI_AddInfo::tr( "GROUP_ON_FILTER" ));
1832                 }
1833                 
1834                 // size
1835                 QTreeWidgetItem* sizeItem = createItem( it );
1836                 sizeItem->setText( 0, SMESHGUI_AddInfo::tr( "SIZE" ));
1837                 sizeItem->setText( 1, QString::number( aGrp->Size() ));
1838                 
1839                 // color
1840                 SALOMEDS::Color color = aGrp->GetColor();
1841                 QTreeWidgetItem* colorItem = createItem( it );
1842                 colorItem->setText( 0, SMESHGUI_AddInfo::tr( "COLOR" ));
1843                 colorItem->setBackground( 1, QBrush( QColor( color.R*255., color.G*255., color.B*255.) ));
1844               }
1845             }
1846           }
1847         }
1848       }
1849       else {
1850         //
1851         // show element info
1852         // 
1853         const SMDS_MeshElement* e = actor()->GetObject()->GetMesh()->FindElement( id );
1854         SMESH::Controls::NumericalFunctorPtr afunctor;
1855         if ( !e ) return;
1856         
1857         // element ID && type
1858         QString stype;
1859         switch( e->GetType() ) {
1860         case SMDSAbs_0DElement: stype = SMESHGUI_ElemInfo::tr( "0D_ELEMENT" ); break;
1861         case SMDSAbs_Ball:      stype = SMESHGUI_ElemInfo::tr( "BALL" ); break;
1862         case SMDSAbs_Edge:      stype = SMESHGUI_ElemInfo::tr( "EDGE" ); break;
1863         case SMDSAbs_Face:      stype = SMESHGUI_ElemInfo::tr( "FACE" ); break;
1864         case SMDSAbs_Volume:    stype = SMESHGUI_ElemInfo::tr( "VOLUME" ); break;
1865         default:;
1866         }
1867         if ( stype.isEmpty() ) return;
1868         QTreeWidgetItem* elemItem = createItem( 0, Bold | All );
1869         elemItem->setText( 0, stype );
1870         elemItem->setText( 1, QString( "#%1" ).arg( id ));
1871         // geometry type
1872         QString gtype;
1873         switch( e->GetEntityType() ) {
1874         case SMDSEntity_Triangle:
1875         case SMDSEntity_Quad_Triangle:
1876         case SMDSEntity_BiQuad_Triangle:
1877           gtype = SMESHGUI_ElemInfo::tr( "TRIANGLE" ); break;
1878         case SMDSEntity_Quadrangle:
1879         case SMDSEntity_Quad_Quadrangle:
1880         case SMDSEntity_BiQuad_Quadrangle:
1881           gtype = SMESHGUI_ElemInfo::tr( "QUADRANGLE" ); break;
1882         case SMDSEntity_Polygon:
1883         case SMDSEntity_Quad_Polygon:
1884           gtype = SMESHGUI_ElemInfo::tr( "POLYGON" ); break;
1885         case SMDSEntity_Tetra:
1886         case SMDSEntity_Quad_Tetra:
1887           gtype = SMESHGUI_ElemInfo::tr( "TETRAHEDRON" ); break;
1888         case SMDSEntity_Pyramid:
1889         case SMDSEntity_Quad_Pyramid:
1890           gtype = SMESHGUI_ElemInfo::tr( "PYRAMID" ); break;
1891         case SMDSEntity_Hexa:
1892         case SMDSEntity_Quad_Hexa:
1893         case SMDSEntity_TriQuad_Hexa:
1894           gtype = SMESHGUI_ElemInfo::tr( "HEXAHEDRON" ); break;
1895         case SMDSEntity_Penta:
1896         case SMDSEntity_Quad_Penta:
1897           gtype = SMESHGUI_ElemInfo::tr( "PRISM" ); break;
1898         case SMDSEntity_Hexagonal_Prism:
1899           gtype = SMESHGUI_ElemInfo::tr( "HEX_PRISM" ); break;
1900         case SMDSEntity_Polyhedra:
1901         case SMDSEntity_Quad_Polyhedra:
1902           gtype = SMESHGUI_ElemInfo::tr( "POLYHEDRON" ); break;
1903         default: 
1904           break;
1905         }
1906         if ( !gtype.isEmpty() ) {
1907           QTreeWidgetItem* typeItem = createItem( elemItem, Bold );
1908           typeItem->setText( 0, SMESHGUI_ElemInfo::tr( "TYPE" ));
1909           typeItem->setText( 1, gtype );
1910         }
1911         // quadratic flag (for edges, faces and volumes)
1912         if ( e->GetType() >= SMDSAbs_Edge && e->GetType() <= SMDSAbs_Volume ) {
1913           // quadratic flag
1914           QTreeWidgetItem* quadItem = createItem( elemItem, Bold );
1915           quadItem->setText( 0, SMESHGUI_ElemInfo::tr( "QUADRATIC" ));
1916           quadItem->setText( 1, e->IsQuadratic() ? SMESHGUI_ElemInfo::tr( "YES" ) : SMESHGUI_ElemInfo::tr( "NO" ));
1917         }
1918         if ( const SMDS_BallElement* ball = dynamic_cast<const SMDS_BallElement*>( e )) {
1919           // ball diameter
1920           QTreeWidgetItem* diamItem = createItem( elemItem, Bold );
1921           diamItem->setText( 0, SMESHGUI_ElemInfo::tr( "BALL_DIAMETER" ));
1922           diamItem->setText( 1, QString( "%1" ).arg( ball->GetDiameter() ));
1923         }
1924         // connectivity
1925         QTreeWidgetItem* conItem = createItem( elemItem, Bold );
1926         conItem->setText( 0, SMESHGUI_ElemInfo::tr( "CONNECTIVITY" ));
1927
1928
1929         if( e->GetGeomType() != SMDSGeom_POLYHEDRA ) {
1930           SMDS_ElemIteratorPtr nodeIt = e->nodesIterator();
1931           for ( int idx = 1; nodeIt->more(); idx++ ) {
1932             const SMDS_MeshNode* node = static_cast<const SMDS_MeshNode*>( nodeIt->next() );
1933             nodeInfo( node, idx, e->NbNodes(), conItem );
1934           }
1935         }
1936         else {
1937           const SMDS_VtkVolume* aVtkVolume = dynamic_cast<const SMDS_VtkVolume*>(e);
1938           SMDS_ElemIteratorPtr nodeIt = aVtkVolume->uniqueNodesIterator();
1939           QList<const SMDS_MeshElement*> uniqueNodes;
1940           while ( nodeIt->more() )
1941             uniqueNodes.append( nodeIt->next() );
1942
1943           SMDS_VolumeTool vtool( e );
1944           const int nbFaces = vtool.NbFaces();
1945           for( int face_id = 0; face_id < nbFaces; face_id++ ) {
1946             QTreeWidgetItem* faceItem = createItem( conItem, Bold );
1947             faceItem->setText( 0, QString( "%1 %2 / %3" ).arg( SMESHGUI_ElemInfo::tr( "FACE" )).arg( face_id + 1 ).arg( nbFaces ));
1948             faceItem->setExpanded( true );
1949
1950             const SMDS_MeshNode** aNodeIds = vtool.GetFaceNodes( face_id );
1951             const int nbNodes = vtool.NbFaceNodes( face_id );
1952             for( int node_id = 0; node_id < nbNodes; node_id++ ) {
1953               const SMDS_MeshNode* node = aNodeIds[node_id];
1954               nodeInfo( node, uniqueNodes.indexOf(node) + 1, aVtkVolume->NbUniqueNodes(), faceItem );
1955             }
1956           }
1957         }
1958         //Controls
1959         QTreeWidgetItem* cntrItem = createItem( elemItem, Bold );
1960         cntrItem->setText( 0, SMESHGUI_ElemInfo::tr( "CONTROLS" ));
1961         //Length
1962         if( e->GetType()==SMDSAbs_Edge){
1963           afunctor.reset( new SMESH::Controls::Length() );
1964           afunctor->SetMesh( actor()->GetObject()->GetMesh() );
1965           afunctor->SetPrecision( cprecision );
1966           QTreeWidgetItem* lenItem = createItem( cntrItem, Bold );
1967           lenItem->setText( 0, tr( "LENGTH_EDGES" ));
1968           lenItem->setText( 1, QString( "%1" ).arg( afunctor->GetValue( id )) );
1969         }
1970         if( e->GetType() == SMDSAbs_Face ) {
1971           //Area
1972           afunctor.reset( new SMESH::Controls::Area() );
1973           afunctor->SetMesh( actor()->GetObject()->GetMesh() );
1974           afunctor->SetPrecision( cprecision );
1975           QTreeWidgetItem* areaItem = createItem( cntrItem, Bold );
1976           areaItem->setText( 0, tr( "AREA_ELEMENTS" ));
1977           areaItem->setText( 1, QString( "%1" ).arg( afunctor->GetValue(id) ));
1978           //Taper
1979           if ( e->NbNodes() == 4 ) // see SMESH_Controls.cxx
1980           {
1981             afunctor.reset( new SMESH::Controls::Taper() );
1982             afunctor->SetMesh( actor()->GetObject()->GetMesh() );
1983             afunctor->SetPrecision( cprecision );
1984             QTreeWidgetItem* taperlItem = createItem( cntrItem, Bold );
1985             taperlItem->setText( 0, tr( "TAPER_ELEMENTS" ));
1986             taperlItem->setText( 1, QString( "%1" ).arg( afunctor->GetValue( id )) );
1987             //Wraping angle
1988             afunctor.reset( new SMESH::Controls::Warping() );
1989             afunctor->SetMesh( actor()->GetObject()->GetMesh() );
1990             afunctor->SetPrecision( cprecision );
1991             QTreeWidgetItem* warpItem = createItem( cntrItem, Bold );
1992             warpItem->setText( 0, tr( "WARP_ELEMENTS" ));
1993             warpItem->setText( 1, QString( "%1" ).arg( afunctor->GetValue( id )) );
1994           }
1995           //AspectRatio2D
1996           if ( !e->IsPoly() )
1997           {
1998             afunctor.reset( new SMESH::Controls::AspectRatio() );
1999             afunctor->SetMesh( actor()->GetObject()->GetMesh() );
2000             QTreeWidgetItem* ratlItem = createItem( cntrItem, Bold );
2001             ratlItem->setText( 0, tr( "ASPECTRATIO_ELEMENTS" ));
2002             ratlItem->setText( 1, QString( "%1" ).arg( afunctor->GetValue( id )) );
2003           }
2004           //Minimum angle
2005           afunctor.reset( new SMESH::Controls::MinimumAngle() );
2006           afunctor->SetMesh( actor()->GetObject()->GetMesh() );
2007           afunctor->SetPrecision( cprecision );
2008           QTreeWidgetItem* minanglItem = createItem( cntrItem, Bold );
2009           minanglItem->setText( 0, tr( "MINIMUMANGLE_ELEMENTS" ));
2010           minanglItem->setText( 1, QString( "%1" ).arg( afunctor->GetValue( id )) );
2011           //Skew
2012           if ( e->NbNodes() == 3 || e->NbNodes() == 4 )
2013           {
2014             afunctor.reset( new SMESH::Controls::Skew() );
2015             afunctor->SetMesh( actor()->GetObject()->GetMesh() );
2016             afunctor->SetPrecision( cprecision );
2017             QTreeWidgetItem* skewItem = createItem( cntrItem, Bold );
2018             skewItem->setText( 0, tr( "SKEW_ELEMENTS" ));
2019             skewItem->setText( 1, QString( "%1" ).arg( afunctor->GetValue( id )) );
2020           }
2021           //ElemDiam2D
2022           if ( !e->IsPoly() )
2023           {
2024             afunctor.reset( new SMESH::Controls::MaxElementLength2D() );
2025             afunctor->SetMesh( actor()->GetObject()->GetMesh() );
2026             QTreeWidgetItem* diamItem = createItem( cntrItem, Bold );
2027             diamItem->setText( 0, tr( "MAX_ELEMENT_LENGTH_2D" ));
2028             diamItem->setText( 1, QString( "%1" ).arg( afunctor->GetValue( id )) );
2029           }
2030         }
2031         if( e->GetType() == SMDSAbs_Volume ) {
2032           if ( !e->IsPoly() )
2033           {
2034             //AspectRatio3D
2035             afunctor.reset( new SMESH::Controls::AspectRatio3D() );
2036             afunctor->SetMesh( actor()->GetObject()->GetMesh() );
2037             QTreeWidgetItem* ratlItem3 = createItem( cntrItem, Bold );
2038             ratlItem3->setText( 0, tr( "ASPECTRATIO_3D_ELEMENTS" ));
2039             ratlItem3->setText( 1, QString( "%1" ).arg( afunctor->GetValue( id )) );
2040           }
2041           //Volume
2042           afunctor.reset( new SMESH::Controls::Volume() );
2043           afunctor->SetMesh( actor()->GetObject()->GetMesh() );
2044           QTreeWidgetItem* volItem = createItem( cntrItem, Bold );
2045           volItem->setText( 0, tr( "VOLUME_3D_ELEMENTS" ));
2046           volItem->setText( 1, QString( "%1" ).arg( afunctor->GetValue( id )) );
2047           //ElementDiameter3D
2048           afunctor.reset( new SMESH::Controls::MaxElementLength3D() );
2049           afunctor->SetMesh( actor()->GetObject()->GetMesh() );
2050           QTreeWidgetItem* diam3Item = createItem( cntrItem, Bold );
2051           diam3Item->setText( 0, tr( "MAX_ELEMENT_LENGTH_3D" ));
2052           diam3Item->setText( 1, QString( "%1" ).arg( afunctor->GetValue( id )) );
2053         }
2054
2055         // gravity center
2056         XYZ gc = gravityCenter( e );
2057         QTreeWidgetItem* gcItem = createItem( elemItem, Bold );
2058         gcItem->setText( 0, SMESHGUI_ElemInfo::tr( "GRAVITY_CENTER" ));
2059         QTreeWidgetItem* xItem = createItem( gcItem );
2060         xItem->setText( 0, "X" );
2061         xItem->setText( 1, QString::number( gc.x(), precision > 0 ? 'f' : 'g', qAbs( precision )) );
2062         QTreeWidgetItem* yItem = createItem( gcItem );
2063         yItem->setText( 0, "Y" );
2064         yItem->setText( 1, QString::number( gc.y(), precision > 0 ? 'f' : 'g', qAbs( precision )) );
2065         QTreeWidgetItem* zItem = createItem( gcItem );
2066         zItem->setText( 0, "Z" );
2067         zItem->setText( 1, QString::number( gc.z(), precision > 0 ? 'f' : 'g', qAbs( precision )) );
2068
2069         // normal vector
2070         if( e->GetType() == SMDSAbs_Face ) {
2071           XYZ gc = normal( e );
2072           QTreeWidgetItem* nItem = createItem( elemItem, Bold );
2073           nItem->setText( 0, SMESHGUI_ElemInfo::tr( "NORMAL_VECTOR" ));
2074           QTreeWidgetItem* xItem = createItem( nItem );
2075           xItem->setText( 0, "X" );
2076           xItem->setText( 1, QString::number( gc.x(), precision > 0 ? 'f' : 'g', qAbs( precision )) );
2077           QTreeWidgetItem* yItem = createItem( nItem );
2078           yItem->setText( 0, "Y" );
2079           yItem->setText( 1, QString::number( gc.y(), precision > 0 ? 'f' : 'g', qAbs( precision )) );
2080           QTreeWidgetItem* zItem = createItem( nItem );
2081           zItem->setText( 0, "Z" );
2082           zItem->setText( 1, QString::number( gc.z(), precision > 0 ? 'f' : 'g', qAbs( precision )) );
2083         }
2084
2085         // element position
2086         SMESH::SMESH_Mesh_ptr aMesh = actor()->GetObject()->GetMeshServer();
2087         if ( e->GetType() >= SMDSAbs_Edge && e->GetType() <= SMDSAbs_Volume ) {
2088           if ( !CORBA::is_nil( aMesh )) {
2089             SMESH::ElementPosition pos = aMesh->GetElementPosition( id );
2090             int shapeID = pos.shapeID;
2091             if ( shapeID > 0 ) {
2092               QTreeWidgetItem* shItem = createItem( elemItem, Bold );
2093               QString shapeType;
2094               switch ( pos.shapeType ) {
2095               case GEOM::EDGE:   shapeType = SMESHGUI_ElemInfo::tr( "GEOM_EDGE" );   break;
2096               case GEOM::FACE:   shapeType = SMESHGUI_ElemInfo::tr( "GEOM_FACE" );   break;
2097               case GEOM::VERTEX: shapeType = SMESHGUI_ElemInfo::tr( "GEOM_VERTEX" ); break;
2098               case GEOM::SOLID:  shapeType = SMESHGUI_ElemInfo::tr( "GEOM_SOLID" );  break;
2099               case GEOM::SHELL:  shapeType = SMESHGUI_ElemInfo::tr( "GEOM_SHELL" );  break;
2100               default:           shapeType = SMESHGUI_ElemInfo::tr( "GEOM_SHAPE" );  break;
2101               }
2102               shItem->setText( 0, SMESHGUI_ElemInfo::tr( "POSITION" ));
2103               shItem->setText( 1, QString( "%1 #%2" ).arg( shapeType ).arg( shapeID ));
2104             }
2105           }
2106         }
2107         // groups element belongs to
2108         if ( !CORBA::is_nil( aMesh )) {
2109           SMESH::ListOfGroups_var  groups = aMesh->GetGroups();
2110           QTreeWidgetItem* groupsItem = 0;
2111           for ( CORBA::ULong i = 0; i < groups->length(); i++ ) {
2112             SMESH::SMESH_GroupBase_var aGrp = groups[i];
2113             if ( CORBA::is_nil( aGrp )) continue;
2114             QString aName = aGrp->GetName();
2115             if ( aGrp->GetType() != SMESH::NODE && !aName.isEmpty() && aGrp->Contains( id )) {
2116               if ( !groupsItem ) {
2117                 groupsItem = createItem( elemItem, Bold );
2118                 groupsItem->setText( 0, SMESHGUI_AddInfo::tr( "GROUPS" ));
2119               }
2120               QTreeWidgetItem* it = createItem( groupsItem, Bold );
2121               it->setText( 0, aName.trimmed() );
2122               if ( grp_details ) {
2123                 SMESH::SMESH_Group_var         aStdGroup  = SMESH::SMESH_Group::_narrow( aGrp );
2124                 SMESH::SMESH_GroupOnGeom_var   aGeomGroup = SMESH::SMESH_GroupOnGeom::_narrow( aGrp );
2125                 SMESH::SMESH_GroupOnFilter_var aFltGroup  = SMESH::SMESH_GroupOnFilter::_narrow( aGrp );
2126                 
2127                 // type : group on geometry, standalone group, group on filter
2128                 QTreeWidgetItem* typeItem = createItem( it );
2129                 typeItem->setText( 0, SMESHGUI_AddInfo::tr( "TYPE" ));
2130                 if ( !CORBA::is_nil( aStdGroup )) {
2131                   typeItem->setText( 1, SMESHGUI_AddInfo::tr( "STANDALONE_GROUP" ));
2132                 }
2133                 else if ( !CORBA::is_nil( aGeomGroup )) {
2134                   typeItem->setText( 1, SMESHGUI_AddInfo::tr( "GROUP_ON_GEOMETRY" ));
2135                   GEOM::GEOM_Object_var gobj = aGeomGroup->GetShape();
2136                   _PTR(SObject) sobj = SMESH::ObjectToSObject( gobj );
2137                   if ( sobj ) {
2138                     QTreeWidgetItem* gobjItem = createItem( typeItem );
2139                     gobjItem->setText( 0, SMESHGUI_AddInfo::tr( "GEOM_OBJECT" ));
2140                     gobjItem->setText( 1, sobj->GetName().c_str() );
2141                   }
2142                 }
2143                 else if ( !CORBA::is_nil( aFltGroup )) {
2144                   typeItem->setText( 1, SMESHGUI_AddInfo::tr( "GROUP_ON_FILTER" ));
2145                 }
2146                 
2147                 // size
2148                 QTreeWidgetItem* sizeItem = createItem( it );
2149                 sizeItem->setText( 0, SMESHGUI_AddInfo::tr( "SIZE" ));
2150                 sizeItem->setText( 1, QString::number( aGrp->Size() ));
2151                 
2152                 // color
2153                 SALOMEDS::Color color = aGrp->GetColor();
2154                 QTreeWidgetItem* colorItem = createItem( it );
2155                 colorItem->setText( 0, SMESHGUI_AddInfo::tr( "COLOR" ));
2156                 colorItem->setBackground( 1, QBrush( QColor( color.R*255., color.G*255., color.B*255.) ));
2157               }
2158             }
2159           }
2160         }
2161       }
2162     }
2163   }
2164 }
2165
2166 /*!
2167   \brief Show node information
2168   \param node mesh node for showing
2169   \param index index of current node
2170   \param nbNodes number of unique nodes in element
2171   \param parentItem parent item of tree
2172 */
2173 void SMESHGUI_TreeElemInfo::nodeInfo( const SMDS_MeshNode* node, int index,
2174                                       int nbNodes, QTreeWidgetItem* parentItem )
2175 {
2176   int precision   = SMESHGUI::resourceMgr()->integerValue( "SMESH", "length_precision", 6 );
2177   // node number and ID
2178   QTreeWidgetItem* nodeItem = createItem( parentItem, Bold );
2179   nodeItem->setText( 0, QString( "%1 %2 / %3" ).arg( SMESHGUI_ElemInfo::tr( "NODE" )).arg( index ).arg( nbNodes ));
2180   nodeItem->setText( 1, QString( "#%1" ).arg( node->GetID() ));
2181   nodeItem->setData( 1, TypeRole, ElemConnectivity );
2182   nodeItem->setData( 1, IdRole, node->GetID() );
2183   nodeItem->setExpanded( false );
2184   // node coordinates
2185   QTreeWidgetItem* coordItem = createItem( nodeItem );
2186   coordItem->setText( 0, SMESHGUI_ElemInfo::tr( "COORDINATES" ));
2187   QTreeWidgetItem* xItem = createItem( coordItem );
2188   xItem->setText( 0, "X" );
2189   xItem->setText( 1, QString::number( node->X(), precision > 0 ? 'f' : 'g', qAbs( precision )) );
2190   QTreeWidgetItem* yItem = createItem( coordItem );
2191   yItem->setText( 0, "Y" );
2192   yItem->setText( 1, QString::number( node->Y(), precision > 0 ? 'f' : 'g', qAbs( precision )) );
2193   QTreeWidgetItem* zItem = createItem( coordItem );
2194   zItem->setText( 0, "Z" );
2195   zItem->setText( 1, QString::number( node->Z(), precision > 0 ? 'f' : 'g', qAbs( precision )) );
2196   // node connectivity
2197   QTreeWidgetItem* nconItem = createItem( nodeItem );
2198   nconItem->setText( 0, SMESHGUI_ElemInfo::tr( "CONNECTIVITY" ));
2199   Connectivity connectivity = nodeConnectivity( node );
2200   if ( !connectivity.isEmpty() ) {
2201     QString con = formatConnectivity( connectivity, SMDSAbs_0DElement );
2202     if ( !con.isEmpty() ) {
2203       QTreeWidgetItem* i = createItem( nconItem );
2204       i->setText( 0, SMESHGUI_ElemInfo::tr( "0D_ELEMENTS" ));
2205       i->setText( 1, con );
2206     }
2207     con = formatConnectivity( connectivity, SMDSAbs_Edge );
2208     if ( !con.isEmpty() ) {
2209       QTreeWidgetItem* i = createItem( nconItem );
2210       i->setText( 0, SMESHGUI_ElemInfo::tr( "EDGES" ));
2211       i->setText( 1, con );
2212       i->setData( 1, TypeRole, NodeConnectivity );
2213     }
2214     con = formatConnectivity( connectivity, SMDSAbs_Ball );
2215     if ( !con.isEmpty() ) {
2216       QTreeWidgetItem* i = createItem( nconItem );
2217       i->setText( 0, SMESHGUI_ElemInfo::tr( "BALL_ELEMENTS" ));
2218       i->setText( 1, con );
2219       i->setData( 1, TypeRole, NodeConnectivity );
2220     }
2221     con = formatConnectivity( connectivity, SMDSAbs_Face );
2222     if ( !con.isEmpty() ) {
2223       QTreeWidgetItem* i = createItem( nconItem );
2224       i->setText( 0, SMESHGUI_ElemInfo::tr( "FACES" ));
2225       i->setText( 1, con );
2226       i->setData( 1, TypeRole, NodeConnectivity );
2227     }
2228     con = formatConnectivity( connectivity, SMDSAbs_Volume );
2229     if ( !con.isEmpty() ) {
2230       QTreeWidgetItem* i = createItem( nconItem );
2231       i->setText( 0, SMESHGUI_ElemInfo::tr( "VOLUMES" ));
2232       i->setText( 1, con );
2233       i->setData( 1, TypeRole, NodeConnectivity );
2234     }
2235   }
2236 }
2237 /*!
2238   \brief Internal clean-up (reset widget)
2239 */
2240 void SMESHGUI_TreeElemInfo::clearInternal()
2241 {
2242   myInfo->clear();
2243   myInfo->repaint();
2244 }
2245
2246 /*!
2247   \brief Create new tree item.
2248   \param parent parent tree widget item
2249   \param flags item flag
2250   \return new tree widget item
2251 */
2252 QTreeWidgetItem* SMESHGUI_TreeElemInfo::createItem( QTreeWidgetItem* parent, int flags )
2253 {
2254   QTreeWidgetItem* item;
2255   if ( parent )
2256     item = new QTreeWidgetItem( parent );
2257   else
2258     item = new QTreeWidgetItem( myInfo );
2259
2260   item->setFlags( item->flags() | Qt::ItemIsEditable );
2261
2262   QFont f = item->font( 0 );
2263   f.setBold( true );
2264   for ( int i = 0; i < myInfo->columnCount(); i++ ) {
2265     if ( ( flags & Bold ) && ( i == 0 || flags & All ))
2266       item->setFont( i, f );
2267   }
2268
2269   if ( parent && parent->childCount() == 1 && itemDepth( parent ) == 1 )
2270   {
2271     QString resName = expandedResource( parent );
2272     parent->setExpanded( SMESHGUI::resourceMgr()->booleanValue("SMESH", resName, true ));
2273   }
2274
2275   item->setExpanded( true );
2276   return item;
2277 }
2278
2279 void SMESHGUI_TreeElemInfo::contextMenuEvent( QContextMenuEvent* e )
2280 {
2281   QList< QTreeWidgetItem* > widgets = myInfo->selectedItems();
2282   if ( widgets.isEmpty() ) return;
2283   QTreeWidgetItem* aTreeItem = widgets.first();
2284   int type = aTreeItem->data( 1, TypeRole ).toInt();
2285   int id   = aTreeItem->data( 1, IdRole ).toInt();
2286   QMenu menu;
2287   QAction* a = menu.addAction( tr( "SHOW_ITEM_INFO" ));
2288   if ( type == ElemConnectivity && id > 0 && menu.exec( e->globalPos() ) == a )
2289     emit( itemInfo( id ));
2290   else if ( type == NodeConnectivity && menu.exec( e->globalPos() ) == a )
2291     emit( itemInfo( aTreeItem->text( 1 )) );
2292 }
2293
2294 void SMESHGUI_TreeElemInfo::itemDoubleClicked( QTreeWidgetItem* theItem, int theColumn )
2295 {
2296   if ( theItem ) {
2297     int type = theItem->data( 1, TypeRole ).toInt();
2298     int id   = theItem->data( 1, IdRole ).toInt();
2299     if ( type == ElemConnectivity && id > 0 )
2300       emit( itemInfo( id ));
2301     else if ( type == NodeConnectivity )
2302       emit( itemInfo( theItem->text( 1 )) );
2303   }
2304 }
2305
2306 void SMESHGUI_TreeElemInfo::saveExpanded( QTreeWidgetItem* theItem )
2307 {
2308   if ( theItem )
2309     SMESHGUI::resourceMgr()->setValue("SMESH", expandedResource( theItem ), theItem->isExpanded() );
2310 }
2311
2312 QString SMESHGUI_TreeElemInfo::expandedResource( QTreeWidgetItem* theItem )
2313 {
2314   return QString("Expanded_") + ( isElements() ? "E_" : "N_" ) + theItem->text(0);
2315 }
2316
2317 void SMESHGUI_TreeElemInfo::saveInfo( QTextStream &out )
2318 {
2319   out << QString( 12, '-' ) << "\n";
2320   out << SMESHGUI_ElemInfo::tr( "ELEM_INFO" ) << "\n";
2321   out << QString( 12, '-' ) << "\n";
2322
2323   QTreeWidgetItemIterator it( myInfo );
2324   while ( *it ) {
2325     if ( !( *it )->text(0).isEmpty() ) {
2326       out << QString( SPACING_INFO * itemDepth( *it ), ' ' ) << ( *it )->text(0);
2327       if ( !( *it )->text(1).isEmpty() ) out << ": " << ( *it )->text(1);
2328       out << "\n";
2329     }
2330     ++it;
2331   }
2332   out << "\n";
2333 }
2334
2335 /*!
2336   \class GrpComputor
2337   \brief Mesh information computer
2338   \internal
2339   
2340   The class is created for different computation operation. Currently it is used
2341   to compute number of underlying nodes for the groups.
2342 */
2343
2344 /*!
2345   \brief Contructor
2346 */
2347 GrpComputor::GrpComputor( SMESH::SMESH_GroupBase_ptr grp,
2348                           QTreeWidgetItem*           item,
2349                           QObject*                   parent,
2350                           bool                       toComputeSize)
2351   : QObject( parent ), myItem( item ), myToComputeSize( toComputeSize )
2352 {
2353   myGroup = SMESH::SMESH_GroupBase::_narrow( grp );
2354 }
2355
2356 /*!
2357   \brief Compute function
2358 */
2359 void GrpComputor::compute()
2360 {
2361   if ( !CORBA::is_nil( myGroup ) && myItem ) {
2362     SUIT_OverrideCursor wc;
2363     QTreeWidgetItem* item = myItem;
2364     myItem = 0;
2365     int nb = myToComputeSize ? myGroup->Size() : myGroup->GetNumberOfNodes();
2366     item->treeWidget()->removeItemWidget( item, 1 );
2367     item->setText( 1, QString::number( nb ));
2368   }
2369 }
2370
2371 /*!
2372   \class SMESHGUI_AddInfo
2373   \brief The wigdet shows additional information on the mesh object.
2374 */
2375
2376 /*!
2377   \brief Constructor
2378   \param parent parent widget
2379 */
2380 SMESHGUI_AddInfo::SMESHGUI_AddInfo( QWidget* parent )
2381 : QTreeWidget( parent )
2382 {
2383   setColumnCount( 2 );
2384   header()->setStretchLastSection( true );
2385 #if QT_VERSION < QT_VERSION_CHECK(5, 0, 0)
2386   header()->setResizeMode( 0, QHeaderView::ResizeToContents );
2387 #else
2388   header()->setSectionResizeMode( 0, QHeaderView::ResizeToContents );
2389 #endif
2390   header()->hide();
2391 }
2392
2393 /*!
2394   \brief Destructor
2395 */
2396 SMESHGUI_AddInfo::~SMESHGUI_AddInfo()
2397 {
2398 }
2399
2400 /*!
2401   \brief Show additional information on the selected object
2402   \param obj object being processed (mesh, sub-mesh, group, ID source)
2403 */
2404 void SMESHGUI_AddInfo::showInfo( SMESH::SMESH_IDSource_ptr obj )
2405 {
2406   setProperty( "group_index", 0 );
2407   setProperty( "submesh_index",  0 );
2408   myComputors.clear();
2409   clear();
2410
2411   if ( CORBA::is_nil( obj )) return;
2412
2413   _PTR(SObject) sobj = SMESH::ObjectToSObject( obj );
2414   if ( !sobj ) return;
2415
2416   // name
2417   QTreeWidgetItem* nameItem = createItem( 0, Bold | All );
2418   nameItem->setText( 0, tr( "NAME" ));
2419   nameItem->setText( 1, sobj->GetName().c_str() );
2420   
2421   SMESH::SMESH_Mesh_var      aMesh    = SMESH::SMESH_Mesh::_narrow( obj );
2422   SMESH::SMESH_subMesh_var   aSubMesh = SMESH::SMESH_subMesh::_narrow( obj );
2423   SMESH::SMESH_GroupBase_var aGroup   = SMESH::SMESH_GroupBase::_narrow( obj );
2424   
2425   if ( !aMesh->_is_nil() )
2426     meshInfo( aMesh, nameItem );
2427   else if ( !aSubMesh->_is_nil() )
2428     subMeshInfo( aSubMesh, nameItem );
2429   else if ( !aGroup->_is_nil() )
2430     groupInfo( aGroup.in(), nameItem );
2431 }
2432
2433 /*!
2434   \brief Create new tree item.
2435   \param parent parent tree widget item
2436   \param flags item flag
2437   \return new tree widget item
2438 */
2439 QTreeWidgetItem* SMESHGUI_AddInfo::createItem( QTreeWidgetItem* parent, int flags )
2440 {
2441   QTreeWidgetItem* item;
2442
2443   if ( parent )
2444     item = new QTreeWidgetItem( parent );
2445   else
2446     item = new QTreeWidgetItem( this );
2447
2448   //item->setFlags( item->flags() | Qt::ItemIsEditable );
2449
2450   QFont f = item->font( 0 );
2451   f.setBold( true );
2452   for ( int i = 0; i < columnCount(); i++ ) {
2453     if ( ( flags & Bold ) && ( i == 0 || flags & All ))
2454       item->setFont( i, f );
2455   }
2456
2457   item->setExpanded( true );
2458   return item;
2459 }
2460
2461 /*!
2462   \brief Show mesh info
2463   \param mesh mesh object
2464   \param parent parent tree item
2465 */
2466 void SMESHGUI_AddInfo::meshInfo( SMESH::SMESH_Mesh_ptr mesh, QTreeWidgetItem* parent )
2467 {
2468   // type
2469   GEOM::GEOM_Object_var shape = mesh->GetShapeToMesh();
2470   SMESH::MedFileInfo_var inf = mesh->GetMEDFileInfo();
2471   QTreeWidgetItem* typeItem = createItem( parent, Bold );
2472   typeItem->setText( 0, tr( "TYPE" ));
2473   if ( !CORBA::is_nil( shape )) {
2474     typeItem->setText( 1, tr( "MESH_ON_GEOMETRY" ));
2475     _PTR(SObject) sobj = SMESH::ObjectToSObject( shape );
2476     if ( sobj ) {
2477       QTreeWidgetItem* gobjItem = createItem( typeItem );
2478       gobjItem->setText( 0, tr( "GEOM_OBJECT" ));
2479       gobjItem->setText( 1, sobj->GetName().c_str() );
2480     }
2481   }
2482   else if ( strlen( (char*)inf->fileName ) > 0 ) {
2483     typeItem->setText( 1, tr( "MESH_FROM_FILE" ));
2484     QTreeWidgetItem* fileItem = createItem( typeItem );
2485     fileItem->setText( 0, tr( "FILE_NAME" ));
2486     fileItem->setText( 1, (char*)inf->fileName );
2487   }
2488   else {
2489     typeItem->setText( 1, tr( "STANDALONE_MESH" ));
2490   }
2491   
2492   // groups
2493   myGroups = mesh->GetGroups();
2494   showGroups();
2495
2496   // sub-meshes
2497   mySubMeshes = mesh->GetSubMeshes();
2498   showSubMeshes();
2499 }
2500
2501 /*!
2502   \brief Show sub-mesh info
2503   \param subMesh sub-mesh object
2504   \param parent parent tree item
2505 */
2506 void SMESHGUI_AddInfo::subMeshInfo( SMESH::SMESH_subMesh_ptr subMesh, QTreeWidgetItem* parent )
2507 {
2508   bool isShort = parent->parent() != 0;
2509
2510   if ( !isShort ) {
2511     // parent mesh
2512     _PTR(SObject) sobj = SMESH::ObjectToSObject( subMesh->GetFather() );
2513     if ( sobj ) {
2514       QTreeWidgetItem* nameItem = createItem( parent, Bold );
2515       nameItem->setText( 0, tr( "PARENT_MESH" ));
2516       nameItem->setText( 1, sobj->GetName().c_str() );
2517     }
2518   }
2519   
2520   // shape
2521   GEOM::GEOM_Object_var gobj = subMesh->GetSubShape();
2522   _PTR(SObject) sobj = SMESH::ObjectToSObject( gobj );
2523   if ( sobj ) {
2524     QTreeWidgetItem* gobjItem = createItem( parent, Bold );
2525     gobjItem->setText( 0, tr( "GEOM_OBJECT" ));
2526     gobjItem->setText( 1, sobj->GetName().c_str() );
2527   }
2528 }
2529
2530 /*!
2531   \brief Show group info
2532   \param grp mesh group object
2533   \param parent parent tree item
2534 */
2535 void SMESHGUI_AddInfo::groupInfo( SMESH::SMESH_GroupBase_ptr grp, QTreeWidgetItem* parent )
2536 {
2537   bool isShort = parent->parent() != 0;
2538
2539   SMESH::SMESH_Group_var         aStdGroup  = SMESH::SMESH_Group::_narrow( grp );
2540   SMESH::SMESH_GroupOnGeom_var   aGeomGroup = SMESH::SMESH_GroupOnGeom::_narrow( grp );
2541   SMESH::SMESH_GroupOnFilter_var aFltGroup  = SMESH::SMESH_GroupOnFilter::_narrow( grp );
2542
2543   if ( !isShort ) {
2544     // parent mesh
2545     _PTR(SObject) sobj = SMESH::ObjectToSObject( grp->GetMesh() );
2546     if ( sobj ) {
2547       QTreeWidgetItem* nameItem = createItem( parent, Bold );
2548       nameItem->setText( 0, tr( "PARENT_MESH" ));
2549       nameItem->setText( 1, sobj->GetName().c_str() );
2550     }
2551   }
2552
2553   // type : group on geometry, standalone group, group on filter
2554   QTreeWidgetItem* typeItem = createItem( parent, Bold );
2555   typeItem->setText( 0, tr( "TYPE" ));
2556   if ( !CORBA::is_nil( aStdGroup )) {
2557     typeItem->setText( 1, tr( "STANDALONE_GROUP" ));
2558   }
2559   else if ( !CORBA::is_nil( aGeomGroup )) {
2560     typeItem->setText( 1, tr( "GROUP_ON_GEOMETRY" ));
2561     GEOM::GEOM_Object_var gobj = aGeomGroup->GetShape();
2562     _PTR(SObject) sobj = SMESH::ObjectToSObject( gobj );
2563     if ( sobj ) {
2564       QTreeWidgetItem* gobjItem = createItem( typeItem );
2565       gobjItem->setText( 0, tr( "GEOM_OBJECT" ));
2566       gobjItem->setText( 1, sobj->GetName().c_str() );
2567     }
2568   }
2569   else if ( !CORBA::is_nil( aFltGroup )) {
2570     typeItem->setText( 1, tr( "GROUP_ON_FILTER" ));
2571   }
2572
2573   if ( !isShort ) {
2574     // entity type
2575     QString etype = tr( "UNKNOWN" );
2576     switch( grp->GetType() ) {
2577     case SMESH::NODE:
2578       etype = tr( "NODE" );
2579       break;
2580     case SMESH::EDGE:
2581       etype = tr( "EDGE" );
2582       break;
2583     case SMESH::FACE:
2584       etype = tr( "FACE" );
2585       break;
2586     case SMESH::VOLUME:
2587       etype = tr( "VOLUME" );
2588       break;
2589     case SMESH::ELEM0D:
2590       etype = tr( "0DELEM" );
2591       break;
2592     case SMESH::BALL:
2593       etype = tr( "BALL" );
2594       break;
2595     default:
2596       break;
2597     }
2598     QTreeWidgetItem* etypeItem = createItem( parent, Bold );
2599     etypeItem->setText( 0, tr( "ENTITY_TYPE" ));
2600     etypeItem->setText( 1, etype );
2601   }
2602
2603   SMESH::SMESH_Mesh_var mesh = grp->GetMesh();
2604   bool            meshLoaded = mesh->IsLoaded();
2605
2606   // size. Don't call grp->Size() for GroupOnFilter - issue IPAL52831
2607   int groupSize = -1;
2608   if ( grp->IsNodeInfoAvailable() || CORBA::is_nil( aFltGroup ))
2609     groupSize = grp->Size();
2610
2611   QTreeWidgetItem* sizeItem = createItem( parent, Bold );
2612   sizeItem->setText( 0, tr( "SIZE" ));
2613   if ( groupSize > -1 ) {
2614     sizeItem->setText( 1, QString::number( groupSize ));
2615   }
2616   else {
2617     QPushButton* btn = new QPushButton( tr( meshLoaded ? "COMPUTE" : "LOAD"), this );
2618     setItemWidget( sizeItem, 1, btn );
2619     GrpComputor* comp = new GrpComputor( grp, sizeItem, this, /*size=*/true );
2620     connect( btn, SIGNAL( clicked() ), comp, SLOT( compute() ));
2621     myComputors.append( comp );
2622     if ( !meshLoaded )
2623       connect( btn, SIGNAL( clicked() ), this, SLOT( changeLoadToCompute() ));
2624   }
2625
2626   // color
2627   SALOMEDS::Color color = grp->GetColor();
2628   QTreeWidgetItem* colorItem = createItem( parent, Bold );
2629   colorItem->setText( 0, tr( "COLOR" ));
2630   colorItem->setBackground( 1, QBrush( QColor( color.R*255., color.G*255., color.B*255.) ));
2631
2632   // nb of underlying nodes
2633   if ( grp->GetType() != SMESH::NODE) {
2634     QTreeWidgetItem* nodesItem = createItem( parent, Bold );
2635     nodesItem->setText( 0, tr( "NB_NODES" ));
2636     int nbNodesLimit = SMESHGUI::resourceMgr()->integerValue( "SMESH", "info_groups_nodes_limit", 100000 );
2637     bool toShowNodes = groupSize >= 0 ? ( grp->IsNodeInfoAvailable() || nbNodesLimit <= 0 || groupSize <= nbNodesLimit ) : false;
2638     if ( toShowNodes && meshLoaded ) {
2639       // already calculated and up-to-date
2640       nodesItem->setText( 1, QString::number( grp->GetNumberOfNodes() ));
2641     }
2642     else {
2643       QPushButton* btn = new QPushButton( tr( meshLoaded ? "COMPUTE" : "LOAD"), this );
2644       setItemWidget( nodesItem, 1, btn );
2645       GrpComputor* comp = new GrpComputor( grp, nodesItem, this ); 
2646       connect( btn, SIGNAL( clicked() ), comp, SLOT( compute() ));
2647       myComputors.append( comp );
2648       if ( !meshLoaded )
2649         connect( btn, SIGNAL( clicked() ), this, SLOT( changeLoadToCompute() ));
2650     }
2651   }
2652 }
2653
2654 void SMESHGUI_AddInfo::showGroups()
2655 {
2656   myComputors.clear();
2657
2658   QTreeWidgetItem* parent = topLevelItemCount() > 0 ? topLevelItem( 0 ) : 0; // parent should be first top level item
2659   if ( !parent ) return;
2660
2661   int idx = property( "group_index" ).toInt();
2662
2663   QTreeWidgetItem* itemGroups = 0;
2664   for ( int i = 0; i < parent->childCount() && !itemGroups; i++ ) {
2665     if ( parent->child( i )->data( 0, Qt::UserRole ).toInt() == GROUPS_ID ) {
2666       itemGroups = parent->child( i );
2667       ExtraWidget* extra = dynamic_cast<ExtraWidget*>( itemWidget( itemGroups, 1 ));
2668       if ( extra )
2669         extra->updateControls( myGroups->length(), idx );
2670       while ( itemGroups->childCount() ) delete itemGroups->child( 0 ); // clear child items
2671     }
2672   }
2673
2674   QMap<int, QTreeWidgetItem*> grpItems;
2675   for ( int i = idx*MAXITEMS ; i < qMin( (idx+1)*MAXITEMS, (int)myGroups->length() ); i++ ) {
2676     SMESH::SMESH_GroupBase_var grp = myGroups[i];
2677     if ( CORBA::is_nil( grp )) continue;
2678     _PTR(SObject) grpSObj = SMESH::ObjectToSObject( grp );
2679     if ( !grpSObj ) continue;
2680
2681     int grpType = grp->GetType();
2682
2683     if ( !itemGroups ) {
2684       // create top-level groups container item
2685       itemGroups = createItem( parent, Bold | All );
2686       itemGroups->setText( 0, tr( "GROUPS" ));
2687       itemGroups->setData( 0, Qt::UserRole, GROUPS_ID );
2688
2689       // total number of groups > 10, show extra widgets for info browsing
2690       if ((int) myGroups->length() > MAXITEMS ) {
2691         ExtraWidget* extra = new ExtraWidget( this, true );
2692         connect( extra->prev, SIGNAL( clicked() ), this, SLOT( showPreviousGroups() ));
2693         connect( extra->next, SIGNAL( clicked() ), this, SLOT( showNextGroups() ));
2694         setItemWidget( itemGroups, 1, extra );
2695         extra->updateControls( myGroups->length(), idx );
2696       }
2697     }
2698
2699     if ( grpItems.find( grpType ) == grpItems.end() ) {
2700       grpItems[ grpType ] = createItem( itemGroups, Bold | All );
2701       grpItems[ grpType ]->setText( 0, tr( QString( "GROUPS_%1" ).arg( grpType ).toLatin1().constData() ));
2702       itemGroups->insertChild( grpType-1, grpItems[ grpType ] );
2703     }
2704   
2705     // group name
2706     QTreeWidgetItem* grpNameItem = createItem( grpItems[ grpType ] );
2707     grpNameItem->setText( 0, QString( grpSObj->GetName().c_str() ).trimmed() ); // name is trimmed
2708
2709     // group info
2710     groupInfo( grp.in(), grpNameItem );
2711   }
2712 }
2713
2714 void SMESHGUI_AddInfo::showSubMeshes()
2715 {
2716   QTreeWidgetItem* parent = topLevelItemCount() > 0 ? topLevelItem( 0 ) : 0; // parent should be first top level item
2717   if ( !parent ) return;
2718
2719   int idx = property( "submesh_index" ).toInt();
2720
2721   QTreeWidgetItem* itemSubMeshes = 0;
2722   for ( int i = 0; i < parent->childCount() && !itemSubMeshes; i++ ) {
2723     if ( parent->child( i )->data( 0, Qt::UserRole ).toInt() == SUBMESHES_ID ) {
2724       itemSubMeshes = parent->child( i );
2725       ExtraWidget* extra = dynamic_cast<ExtraWidget*>( itemWidget( itemSubMeshes, 1 ));
2726       if ( extra )
2727         extra->updateControls( mySubMeshes->length(), idx );
2728       while ( itemSubMeshes->childCount() ) delete itemSubMeshes->child( 0 ); // clear child items
2729     }
2730   }
2731
2732   QMap<int, QTreeWidgetItem*> smItems;
2733   for ( int i = idx*MAXITEMS ; i < qMin( (idx+1)*MAXITEMS, (int)mySubMeshes->length() ); i++ ) {
2734     SMESH::SMESH_subMesh_var sm = mySubMeshes[i];
2735     if ( CORBA::is_nil( sm )) continue;
2736     _PTR(SObject) smSObj = SMESH::ObjectToSObject( sm );
2737     if ( !smSObj ) continue;
2738     
2739     GEOM::GEOM_Object_var gobj = sm->GetSubShape();
2740     if ( CORBA::is_nil(gobj )) continue;
2741     
2742     int smType = gobj->GetShapeType();
2743     if ( smType == GEOM::COMPSOLID ) smType = GEOM::COMPOUND;
2744
2745     if ( !itemSubMeshes ) {
2746       itemSubMeshes = createItem( parent, Bold | All );
2747       itemSubMeshes->setText( 0, tr( "SUBMESHES" ));
2748       itemSubMeshes->setData( 0, Qt::UserRole, SUBMESHES_ID );
2749
2750       // total number of sub-meshes > 10, show extra widgets for info browsing
2751       if ((int) mySubMeshes->length() > MAXITEMS ) {
2752         ExtraWidget* extra = new ExtraWidget( this, true );
2753         connect( extra->prev, SIGNAL( clicked() ), this, SLOT( showPreviousSubMeshes() ));
2754         connect( extra->next, SIGNAL( clicked() ), this, SLOT( showNextSubMeshes() ));
2755         setItemWidget( itemSubMeshes, 1, extra );
2756         extra->updateControls( mySubMeshes->length(), idx );
2757       }
2758     }
2759          
2760     if ( smItems.find( smType ) == smItems.end() ) {
2761       smItems[ smType ] = createItem( itemSubMeshes, Bold | All );
2762       smItems[ smType ]->setText( 0, tr( QString( "SUBMESHES_%1" ).arg( smType ).toLatin1().constData() ));
2763       itemSubMeshes->insertChild( smType, smItems[ smType ] );
2764     }
2765     
2766     // submesh name
2767     QTreeWidgetItem* smNameItem = createItem( smItems[ smType ] );
2768     smNameItem->setText( 0, QString( smSObj->GetName().c_str() ).trimmed() ); // name is trimmed
2769     
2770     // submesh info
2771     subMeshInfo( sm.in(), smNameItem );
2772   }
2773 }
2774
2775 /*!
2776  * \brief Change button label of "nb underlying node" group from "Load" to "Compute"
2777  */
2778 void SMESHGUI_AddInfo::changeLoadToCompute()
2779 {
2780   for ( int i = 0; i < myComputors.count(); ++i )
2781   {
2782     if ( QTreeWidgetItem* item = myComputors[i]->getItem() )
2783     {
2784       if ( QPushButton* btn = qobject_cast<QPushButton*>( itemWidget ( item, 1 )) )
2785         btn->setText( tr("COMPUTE") );
2786     }
2787   }
2788 }
2789
2790 void SMESHGUI_AddInfo::showPreviousGroups()
2791 {
2792   int idx = property( "group_index" ).toInt();
2793   setProperty( "group_index", idx-1 );
2794   showGroups();
2795 }
2796
2797 void SMESHGUI_AddInfo::showNextGroups()
2798 {
2799   int idx = property( "group_index" ).toInt();
2800   setProperty( "group_index", idx+1 );
2801   showGroups();
2802 }
2803
2804 void SMESHGUI_AddInfo::showPreviousSubMeshes()
2805 {
2806   int idx = property( "submesh_index" ).toInt();
2807   setProperty( "submesh_index", idx-1 );
2808   showSubMeshes();
2809 }
2810
2811 void SMESHGUI_AddInfo::showNextSubMeshes()
2812 {
2813   int idx = property( "submesh_index" ).toInt();
2814   setProperty( "submesh_index", idx+1 );
2815   showSubMeshes();
2816 }
2817
2818 void SMESHGUI_AddInfo::saveInfo( QTextStream &out )
2819 {
2820   out << QString( 15, '-')       << "\n";
2821   out << tr( "ADDITIONAL_INFO" ) << "\n";
2822   out << QString( 15, '-' )      << "\n";
2823   QTreeWidgetItemIterator it( this );
2824   while ( *it ) {
2825     if ( !( ( *it )->text(0) ).isEmpty() ) {
2826       out << QString( SPACING_INFO * itemDepth( *it ), ' ' ) << ( *it )->text(0);
2827       if ( ( *it )->text(0)  == tr( "COLOR" )) {
2828         out << ": " << ( ( ( *it )->background(1) ).color() ).name();
2829       }
2830       else if ( !( ( *it )->text(1) ).isEmpty() ) out << ": " << ( *it )->text(1);
2831       out << "\n";
2832     }
2833     ++it;
2834   }
2835   out << "\n";
2836 }
2837
2838 /*!
2839   \class SMESHGUI_MeshInfoDlg
2840   \brief Mesh information dialog box
2841 */
2842
2843 /*!
2844   \brief Constructor
2845   \param parent parent widget
2846   \param page specifies the dialog page to be shown at the start-up
2847 */
2848 SMESHGUI_MeshInfoDlg::SMESHGUI_MeshInfoDlg( QWidget* parent, int page )
2849   : QDialog( parent ), myActor( 0 )
2850 {
2851   setModal( false );
2852   setAttribute( Qt::WA_DeleteOnClose, true );
2853   setWindowTitle( tr( "MESH_INFO" ));
2854   setSizeGripEnabled( true );
2855
2856   myTabWidget = new QTabWidget( this );
2857
2858   // base info
2859
2860   myBaseInfo = new SMESHGUI_MeshInfo( myTabWidget );
2861   myTabWidget->addTab( myBaseInfo, tr( "BASE_INFO" ));
2862
2863   // elem info 
2864
2865   QWidget* w = new QWidget( myTabWidget );
2866
2867   myMode = new QButtonGroup( this );
2868   myMode->addButton( new QRadioButton( tr( "NODE_MODE" ), w ), NodeMode );
2869   myMode->addButton( new QRadioButton( tr( "ELEM_MODE" ), w ), ElemMode );
2870   myMode->button( NodeMode )->setChecked( true );
2871   myID = new QLineEdit( w );
2872   myID->setValidator( new SMESHGUI_IdValidator( this ));
2873   myIDPreviewCheck = new QCheckBox( tr(&nbs