Salome HOME
23636: EDF 18217 - Problem when suppressing CAD
[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
23 #include "SMESHGUI_MeshInfo.h"
24
25 #include "SMDS_Mesh.hxx"
26 #include "SMESH_Actor.h"
27 #include "SMESHGUI.h"
28 #include "SMESHGUI_FilterUtils.h"
29 #include "SMESHGUI_IdPreview.h"
30 #include "SMESHGUI_IdValidator.h"
31 #include "SMESHGUI_SpinBox.h"
32 #include "SMESHGUI_Utils.h"
33 #include "SMESHGUI_VTKUtils.h"
34
35 #include <SUIT_FileDlg.h>
36 #include <SUIT_OverrideCursor.h>
37 #include <SUIT_ResourceMgr.h>
38 #include <SUIT_Session.h>
39 #include <SVTK_ViewWindow.h>
40 #include <LightApp_SelectionMgr.h>
41
42 #include <SALOMEDSClient_Study.hxx>
43
44 #include <QApplication>
45 #include <QButtonGroup>
46 #include <QCheckBox>
47 #include <QComboBox>
48 #include <QContextMenuEvent>
49 #include <QGridLayout>
50 #include <QHBoxLayout>
51 #include <QHeaderView>
52 #include <QItemDelegate>
53 #include <QKeyEvent>
54 #include <QLabel>
55 #include <QLineEdit>
56 #include <QMenu>
57 #include <QPushButton>
58 #include <QRadioButton>
59 #include <QStackedWidget>
60 #include <QStandardItemModel>
61 #include <QTabWidget>
62 #include <QTextBrowser>
63 #include <QTextStream>
64 #include <QToolButton>
65 #include <QTreeWidget>
66 #include <QVBoxLayout>
67
68 ////////////////////////////////////////////////////////////////////////////////
69 /// \class Field
70 /// \brief Field widget.
71 /// \internal
72 ////////////////////////////////////////////////////////////////////////////////
73
74 class Field : public QLabel
75 {
76 public:
77   Field( QWidget*, const QString& = QString() );
78   bool event( QEvent* );
79 };
80
81 /*!
82   \brief Constructor.
83   \param parent Parent widget.
84   \param name Field name. Defauls to null string.
85 */
86 Field::Field( QWidget* parent, const QString& name ): QLabel( parent )
87 {
88   setFrameStyle( QLabel::StyledPanel | QLabel::Sunken );
89   setAlignment( Qt::AlignCenter );
90   setAutoFillBackground( true );
91   QPalette pal = palette();
92   QColor base = QApplication::palette().color( QPalette::Active, QPalette::Base );
93   pal.setColor( QPalette::Window, base );
94   setPalette( pal );
95   setMinimumWidth( 60 );
96   if ( !name.isEmpty() )
97     setObjectName( name );
98 }
99
100 /*!
101   \brief Event handler. Redefined from QLabel.
102 */
103 bool Field::event( QEvent* e )
104 {
105   if ( e->type() == QEvent::DynamicPropertyChange )
106   {
107     QDynamicPropertyChangeEvent* ce = (QDynamicPropertyChangeEvent*)e;
108     if ( ce->propertyName() == "value" && property( "value" ).isValid() )
109     {
110       setText( QString::number( property( "value" ).toInt() ) );
111       setProperty( "value", QVariant() );
112       return true;
113     }
114   }
115   return QLabel::event( e );
116 }
117
118 ////////////////////////////////////////////////////////////////////////////////
119 /// \class TreeItemCreator
120 /// \brief Generic tree item creator.
121 /// \internal
122 ////////////////////////////////////////////////////////////////////////////////
123
124 class TreeItemCreator
125 {
126 public:
127   TreeItemCreator() {}
128   virtual ~TreeItemCreator() {}
129   virtual QTreeWidgetItem* createItem( QTreeWidgetItem*, int ) = 0;
130 };
131
132 ////////////////////////////////////////////////////////////////////////////////
133 // General purpose services.
134 ////////////////////////////////////////////////////////////////////////////////
135
136 namespace
137 {
138   const int SPACING = 6;
139   const int MARGIN = 9;
140
141   enum
142   {
143     Bold = 0x01,
144     Italic = 0x02,
145     AllColumns = 0x04,
146     Expanded = 0x08,
147     Editable = 0x10
148   };
149
150   enum
151   {
152     GroupsId = 100,
153     SubMeshesId
154   };
155
156   enum
157   {
158     TypeRole = Qt::UserRole + 10,
159     IdRole,
160   };
161
162   enum
163   {
164     NodeConnectivity = 100,
165     ElemConnectivity,
166   };
167
168   /*!
169     \brief Get item's depth in the tree.
170     \param item Tree widget item.
171     \return Item's depth in the tree widget (top-level item has zero depth).
172     \internal
173   */
174   int itemDepth( QTreeWidgetItem* item )
175   {
176     QList<QTreeWidgetItem*> parents;
177     parents << item;
178     while ( parents.last()->parent() )
179       parents << parents.last()->parent();
180     return parents.size()-1;
181   }
182
183   /*!
184     \brief Get chunk size.
185     \return Chunk size.
186     \internal
187   */
188   int blockSize()
189   {
190     return 10;
191   }
192
193   /*!
194     \brief Get spacer.
195     \return Spacer string.
196     \internal
197   */
198   QString spacing()
199   {
200     static int size = 1;
201     static QChar spacer = ' ';
202     return QString( size, spacer );
203   }
204
205   /*!
206     \brief Get indent.
207     \param length Indent size. Defaults to 1.
208     \return Indentation string.
209     \internal
210   */
211   QString indent( int length = 1 )
212   {
213     static int size = 4;
214     static QChar spacer = ' ';
215     return QString( size * length, spacer );
216   }
217
218   /*!
219     \brief Get indent.
220     \param spacer Spacer.
221     \param length Indent size. Defaults to 1.
222     \return Indentation string.
223     \internal
224   */
225   QString indent( const QString& spacer, uint length = 1 )
226   {
227     QString result;
228     while( length-- > 0 )
229       result += spacer;
230     return result;
231   }
232
233   /*!
234     \brief Get group separator.
235     \param length Length of ruler (number of symbols). Defaults to 80.
236     \return Ruler string.
237     \internal
238   */
239   QString ruler( int length = 80 )
240   {
241     static QChar ruler = '-';
242     return QString( length, ruler );
243   }
244
245   /*!
246     \brief Get text value from label.
247     \param w Widget (QLabel).
248     \return Value string.
249     \internal
250   */
251   QString widgetValue( QWidget* w )
252   {
253     QString v;
254     if ( qobject_cast<QLabel*>( w ) )
255       v = qobject_cast<QLabel*>( w )->text();
256     return v;
257   }
258
259   /*!
260     \brief Get font for given options.
261     \param font Initial font.
262     \param options Font attributes.
263     \return Font.
264   */
265   QFont fontFromOptions( const QFont& font, int options )
266   {
267     QFont f = font;
268     f.setBold( options & Bold );
269     f.setItalic( options & Italic );
270     return f;
271   }
272
273   /*!
274     \brief Set font attributes to given widget.
275     \param w Widget.
276     \param options Font attributes.
277   */
278   void setFontAttributes( QWidget* w, int options )
279   {
280     if ( w )
281       w->setFont( fontFromOptions( w->font(), options ) );
282   }
283
284   /*!
285     \brief Set attributes to given tree item.
286     \param item Tree widget item.
287     \param options Item attributes.
288   */
289   void setTreeItemAttributes( QTreeWidgetItem* item, int options )
290   {
291     if ( item && item->treeWidget() )
292     {
293       for ( int i = 0; i < item->treeWidget()->columnCount(); i++ )
294       {
295         if ( i == 0 || options & AllColumns )
296           item->setFont( i, fontFromOptions( item->font( 0 ), options) );
297       }
298     }
299     if ( options & Expanded )
300       item->setExpanded( true );
301     if ( options & Editable )
302       item->setFlags( item->flags() | Qt::ItemIsEditable );
303   }
304
305   /*!
306     \brief Create label.
307     \param parent Parent widget.
308     \param options Label options. Defaults to 0 (none).
309     \return New label.
310   */
311   QLabel* createLabel( QWidget* parent, int options = 0 )
312   {
313     QLabel* lab = new QLabel( parent );
314     setFontAttributes( lab, options );
315     return lab;
316   }
317
318   /*!
319     \brief Create label.
320     \param text Label text.
321     \param parent Parent widget.
322     \param options Label options. Defaults to 0 (none).
323     \return New label.
324   */
325   QLabel* createLabel( const QString& text, QWidget* parent, int options = 0 )
326   {
327     QLabel* lab = createLabel( parent, options );
328     lab->setText( text );
329     return lab;
330   }
331
332   /*!
333     \brief Create information field.
334     \param parent Parent widget.
335     \param name Field's object. Default to null string.
336     \return New field.
337   */
338   QLabel* createField( QWidget* parent, const QString& name = QString() )
339   {
340     return new Field( parent, name );
341   }
342
343   /*!
344     \brief Create information field.
345     \param parent Parent widget.
346     \param options Label options.
347     \param name Field's object. Default to null string.
348     \return New field.
349   */
350   QLabel* createField( QWidget* parent, int options, const QString& name = QString() )
351   {
352     QLabel* field = createField( parent, name );
353     setFontAttributes( field, options );
354     return field;
355   }
356
357   /*!
358     \brief Create ruler.
359     \param parent Parent widget.
360     \param orientation Ruler orientation. Defaults to horizontal.
361     \return New ruler.
362   */
363   QWidget* createSeparator( QWidget* parent, Qt::Orientation orientation = Qt::Horizontal )
364   {
365     QFrame* line = new QFrame( parent );
366     line->setFrameShape( orientation == Qt::Horizontal ? QFrame::HLine : QFrame::HLine );
367     line->setFrameShadow( QFrame::Sunken );
368     return line;
369   }
370
371   /*!
372     \brief Decorate text as bold.
373     \param text Initial text.
374     \return Decorated text.
375   */
376   QString bold( const QString& text )
377   {
378     return QString("<b>%1</b>").arg( text );
379   }
380
381   /*!
382     \brief Format connectivity data to string representation.
383     \param connectivity Connectivity map.
384     \param type Element type or face index if negative
385     \return Stringifed representation of the connectivity.
386   */
387   QString formatConnectivity( SMESH::Connectivity connectivity, int type )
388   {
389     QStringList str;
390     QString     result;
391     bool isNodal = ( type == SMDSAbs_Node || type < 0 );
392     type = qAbs( type );
393     if ( connectivity.contains( type ))
394     {
395       QList<int> elements = connectivity[ type ];
396       if ( !isNodal ) // order of nodes is important
397         qSort( elements );
398       foreach( int id, elements )
399         str << QString::number( id );
400
401       // wrap IDs into an html link, to be treated by QTextBrowser used by SMESHGUI_SimpleElemInfo
402       QString s = str.join( " " );
403       result = ( "<a href = \"" +                                 // URL:
404                  QString( isNodal ? "nodes" : "elems" ) + "://" + // protocol
405                  QString( "host.com/") + // QUrl return nothing if host missing
406                  s + "\">" +                                      // path
407                  s + "</a>" );                                    // anchor text
408     }
409     return result;
410   }
411 } // end of anonymous namespace
412
413 ////////////////////////////////////////////////////////////////////////////////
414 /// \class SMESHGUI_Info
415 /// \brief Base widget for all information panes.
416 ////////////////////////////////////////////////////////////////////////////////
417
418 /*!
419   \brief Constructor.
420   \param parent Parent widget. Defaults to 0.
421 */
422 SMESHGUI_Info::SMESHGUI_Info( QWidget* parent ): QWidget( parent )
423 {
424 }
425
426 ////////////////////////////////////////////////////////////////////////////////
427 /// \class ExtraWidget
428 /// \brief Auxiliary widget to browse between chunks of information.
429 /// \internal
430 ////////////////////////////////////////////////////////////////////////////////
431
432 class ExtraWidget : public QWidget
433 {
434 public:
435   ExtraWidget( QWidget*, bool = false );
436   void updateControls( int, int );
437
438 public:
439   QLabel* current;
440   QPushButton* prev;
441   QPushButton* next;
442   bool brief;
443 };
444
445 /*
446   \brief Constructor.
447   \param parent Parent widget.
448   \param briefSummary Show summary in brief format. Defaults to \c false.
449 */
450 ExtraWidget::ExtraWidget( QWidget* parent, bool briefSummary ): QWidget( parent ), brief( briefSummary )
451 {
452   current = new QLabel( this );
453   current->setAlignment( Qt::AlignRight | Qt::AlignVCenter );
454   prev = new QPushButton( "<<", this );
455   next = new QPushButton( ">>", this );
456   QHBoxLayout* hbl = new QHBoxLayout( this );
457   hbl->setMargin( 0 );
458   hbl->setSpacing( SPACING );
459   hbl->addStretch();
460   hbl->addWidget( current );
461   hbl->addWidget( prev );
462   hbl->addWidget( next );
463 }
464
465 /*
466   \brief Update controls.
467   \param total Total number of items.
468   \param index Current index.
469 */
470 void ExtraWidget::updateControls( int total, int index )
471 {
472   setVisible( total > blockSize() );
473   QString format = brief ? QString( "%1-%2 / %3" ) : SMESHGUI_MeshInfoDlg::tr( "X_FROM_Y_ITEMS_SHOWN" );
474   current->setText( format.arg( index*blockSize()+1 ).arg( qMin( index*blockSize()+blockSize(), total ) ).arg( total ) );
475   prev->setEnabled( index > 0 );
476   next->setEnabled( (index+1)*blockSize() < total );
477 }
478
479 ////////////////////////////////////////////////////////////////////////////////
480 /// \class DumpFileDlg
481 /// \brief Standard Save File dialog box, customized for dump info operation.
482 /// \internal
483 ////////////////////////////////////////////////////////////////////////////////
484
485 class DumpFileDlg : public SUIT_FileDlg
486 {
487   QMap<int, QCheckBox*> myControls;
488 public:
489   DumpFileDlg( QWidget*, bool = true );
490   bool isChecked( int ) const;
491   void setChecked( int, bool );
492 };
493
494 /*!
495   \brief Constructor.
496   \param parent Parent widget.
497   \param showControls Show additional controls. Defaults to \c true.
498   \internal
499 */
500 DumpFileDlg::DumpFileDlg( QWidget* parent, bool showControls ): SUIT_FileDlg( parent, false, true, true )
501 {
502   if ( showControls )
503   {
504     QWidget* hB = new QWidget( this );
505     myControls[SMESHGUI_MeshInfoDlg::BaseInfo] = new QCheckBox( SMESHGUI::tr( "PREF_DUMP_BASE_INFO" ), hB );
506     myControls[SMESHGUI_MeshInfoDlg::ElemInfo] = new QCheckBox( SMESHGUI::tr( "PREF_DUMP_ELEM_INFO" ), hB );
507     myControls[SMESHGUI_MeshInfoDlg::AddInfo] = new QCheckBox( SMESHGUI::tr( "PREF_DUMP_ADD_INFO" ),  hB );
508     myControls[SMESHGUI_MeshInfoDlg::CtrlInfo] = new QCheckBox( SMESHGUI::tr( "PREF_DUMP_CTRL_INFO" ), hB );
509
510     QGridLayout* layout = new QGridLayout( hB );
511     layout->setMargin( 0 );
512     layout->addWidget( myControls[SMESHGUI_MeshInfoDlg::BaseInfo], 0, 0 );
513     layout->addWidget( myControls[SMESHGUI_MeshInfoDlg::ElemInfo], 0, 1 );
514     layout->addWidget( myControls[SMESHGUI_MeshInfoDlg::AddInfo], 1, 0 );
515     layout->addWidget( myControls[SMESHGUI_MeshInfoDlg::CtrlInfo], 1, 1 );
516
517     addWidgets( 0, hB, 0 );
518   }
519 }
520
521 /*!
522   \brief Get control's value.
523   \param option Control identifier.
524   \return Control value.
525   \internal
526 */
527 bool DumpFileDlg::isChecked( int option ) const
528 {
529   return myControls.contains( option ) ? myControls[option]->isChecked() : false;
530 }
531
532 /*!
533   \brief Set control's initial value.
534   \param option Control identifier.
535   \param value Control value.
536   \internal
537 */
538 void DumpFileDlg::setChecked( int option, bool value )
539 {
540   if ( myControls.contains( option ) ) 
541     myControls[option]->setChecked( value );
542 }
543
544 ////////////////////////////////////////////////////////////////////////////////
545 /// \class SMESHGUI_BaseInfo
546 /// \brief Show basic information on selected object.
547 ///
548 /// Displays the base information about selected object: mesh, sub-mesh, group
549 /// or arbitrary ID source.
550 /// \todo Hide unnecessary widgets (e.g. for mesh group).
551 ////////////////////////////////////////////////////////////////////////////////
552
553 /*!
554   \brief Constructor.
555   \param parent Parent widget. Defaults to 0.
556 */
557 SMESHGUI_BaseInfo::SMESHGUI_BaseInfo( QWidget* parent ): SMESHGUI_Info( parent )
558 {
559   QGridLayout* l = new QGridLayout( this );
560   l->setMargin( MARGIN );
561   l->setSpacing( SPACING );
562
563   // object info
564   // - name
565   addWidget( createLabel( tr( "NAME_LAB" ), this, Bold ), iName, iLabel );
566   addWidget( createField( this, "meshName" ), iName, iSingle, 4 )->setMinimumWidth( 150 );
567   // - type
568   addWidget( createLabel( tr( "OBJECT_LAB" ), this, Bold ), iObject, iLabel );
569   addWidget( createField( this, "meshType" ), iObject, iSingle, 4 )->setMinimumWidth( 150 );
570   // - --- (separator)
571   addWidget( createSeparator( this ), iObjectEnd, iLabel, 5 );
572
573   // node info
574   // - info
575   addWidget( createLabel( tr( "NODES_LAB" ), this, Bold ), iNodes, iLabel );
576   addWidget( createField( this, "nbNodes" ), iNodes, iTotal );
577   // - --- (separator)
578   addWidget( createSeparator( this ), iNodesEnd, iLabel, 5 );
579
580   // element info
581   // - title
582   addWidget( createLabel( tr( "ELEMENTS_LAB" ), this, Bold ), iElementsTitle, iLabel );
583   addWidget( createLabel( tr( "TOTAL_LAB" ), this, Italic ), iElementsTitle, iTotal );
584   addWidget( createLabel( tr( "LINEAR_LAB" ), this, Italic ), iElementsTitle, iLinear );
585   addWidget( createLabel( tr( "QUADRATIC_LAB" ), this, Italic ), iElementsTitle, iQuadratic );
586   addWidget( createLabel( tr( "BI_QUADRATIC_LAB" ), this, Italic ), iElementsTitle, iBiQuadratic );
587   // - --- (separator)
588   addWidget( createSeparator( this ), iElementsTitleEnd, iTotal, 4 );
589   // - summary
590   addWidget( createField( this, "totalNbElems" ), iElementsTotal, iTotal );
591   addWidget( createField( this, "totalNbLinearElems" ), iElementsTotal, iLinear );
592   addWidget( createField( this, "totalNbQuadraticElems" ), iElementsTotal, iQuadratic );
593   addWidget( createField( this, "totalNbBiQuadraticElems" ), iElementsTotal, iBiQuadratic );
594   // - --- (separator)
595   addWidget( createSeparator( this ), iElementsTotalEnd, iTotal, 4 );
596   // - 0D elements info
597   addWidget( createLabel( tr( "0D_LAB" ), this, Bold | Italic ), i0D, iLabel );
598   addWidget( createField( this, "nb0D" ), i0D, iTotal );
599   // - --- (separator)
600   addWidget( createSeparator( this ), i0DEnd, iTotal, 4 );
601   // - balls info
602   addWidget( createLabel( tr( "BALL_LAB" ), this, Bold | Italic ), iBalls, iLabel );
603   addWidget( createField( this, "nbBall" ), iBalls, iTotal );
604   // - --- (separator)
605   addWidget( createSeparator( this ), iBallsEnd, iTotal, 4 );
606   // - 1D elements info
607   addWidget( createLabel( tr( "1D_LAB" ), this, Bold | Italic ), i1D, iLabel );
608   addWidget( createField( this, "nb1D" ), i1D, iTotal );
609   addWidget( createField( this, "nbLinear1D" ), i1D, iLinear );
610   addWidget( createField( this, "nbQuadratic1D" ), i1D, iQuadratic );
611   // - --- (separator)
612   addWidget( createSeparator( this ), i1DEnd, iTotal, 4 );
613   // - 2D elements info
614   // --+ summary
615   addWidget( createLabel( tr( "2D_LAB" ), this, Bold | Italic ), i2D, iLabel );
616   addWidget( createField( this, "nb2D" ), i2D, iTotal );
617   addWidget( createField( this, "nbLinear2D" ), i2D, iLinear );
618   addWidget( createField( this, "nbQuadratic2D" ), i2D, iQuadratic );
619   addWidget( createField( this, "nbBiQuadratic2D" ), i2D, iBiQuadratic );
620   // --+ triangles
621   addWidget( createLabel( tr( "TRIANGLES_LAB" ), this, Italic ), i2DTriangles, iLabel );
622   addWidget( createField( this, Italic, "nbTriangle" ), i2DTriangles, iTotal );
623   addWidget( createField( this, Italic, "nbLinearTriangle" ), i2DTriangles, iLinear );
624   addWidget( createField( this, Italic, "nbQuadraticTriangle" ), i2DTriangles, iQuadratic );
625   addWidget( createField( this, Italic, "nbBiQuadraticTriangle" ), i2DTriangles, iBiQuadratic );
626   // --+ quadrangles
627   addWidget( createLabel( tr( "QUADRANGLES_LAB" ), this, Italic ), i2DQuadrangles, iLabel );
628   addWidget( createField( this, Italic, "nbQuadrangle" ), i2DQuadrangles, iTotal );
629   addWidget( createField( this, Italic, "nbLinearQuadrangle" ), i2DQuadrangles, iLinear );
630   addWidget( createField( this, Italic, "nbQuadraticQuadrangle" ), i2DQuadrangles, iQuadratic );
631   addWidget( createField( this, Italic, "nbBiQuadraticQuadrangle" ), i2DQuadrangles, iBiQuadratic );
632   // --+ polygons
633   addWidget( createLabel( tr( "POLYGONS_LAB" ), this, Italic ), i2DPolygons, iLabel );
634   addWidget( createField( this, Italic, "nbPolygon" ), i2DPolygons, iTotal );
635   addWidget( createField( this, Italic, "nbLinearPolygon" ), i2DPolygons, iLinear );
636   addWidget( createField( this, Italic, "nbQuadraticPolygon" ), i2DPolygons, iQuadratic );
637   // - --- (separator)
638   addWidget( createSeparator( this ), i2DEnd, iTotal, 4 );
639   // - 3D elements info
640   // --+ summary
641   addWidget( createLabel( tr( "3D_LAB" ), this, Bold | Italic ), i3D, iLabel );
642   addWidget( createField( this, "nb3D" ), i3D, iTotal );
643   addWidget( createField( this, "nbLinear3D" ), i3D, iLinear );
644   addWidget( createField( this, "nbQuadratic3D" ), i3D, iQuadratic );
645   addWidget( createField( this, "nbBiQuadratic3D" ), i3D, iBiQuadratic );
646   // --+ tetras
647   addWidget( createLabel( tr( "TETRAHEDRONS_LAB" ), this, Italic ), i3DTetrahedrons, iLabel );
648   addWidget( createField( this, Italic, "nbTetrahedron" ), i3DTetrahedrons, iTotal );
649   addWidget( createField( this, Italic, "nbLinearTetrahedron" ), i3DTetrahedrons, iLinear );
650   addWidget( createField( this, Italic, "nbQudraticTetrahedron" ), i3DTetrahedrons, iQuadratic );
651   // --+ hexas
652   addWidget( createLabel( tr( "HEXAHEDONRS_LAB" ), this, Italic ), i3DHexahedrons, iLabel );
653   addWidget( createField( this, Italic, "nbHexahedron" ), i3DHexahedrons, iTotal );
654   addWidget( createField( this, Italic, "nbLinearHexahedron" ), i3DHexahedrons, iLinear );
655   addWidget( createField( this, Italic, "nbQuadraticHexahedron" ), i3DHexahedrons, iQuadratic );
656   addWidget( createField( this, Italic, "nbBiQuadraticHexahedron" ), i3DHexahedrons, iBiQuadratic );
657   // --+ pyramids
658   addWidget( createLabel( tr( "PYRAMIDS_LAB" ), this, Italic ), i3DPyramids, iLabel );
659   addWidget( createField( this, Italic, "nbPyramid" ), i3DPyramids, iTotal );
660   addWidget( createField( this, Italic, "nbLinearPyramid" ), i3DPyramids, iLinear );
661   addWidget( createField( this, Italic, "nbQuadraticPyramid" ), i3DPyramids, iQuadratic );
662   // --+ prisms
663   addWidget( createLabel( tr( "PRISMS_LAB" ), this, Italic ), i3DPrisms, iLabel );
664   addWidget( createField( this, Italic, "nbPrism" ), i3DPrisms, iTotal );
665   addWidget( createField( this, Italic, "nbLinearPrism" ), i3DPrisms, iLinear );
666   addWidget( createField( this, Italic, "nbQuadraticPrism" ), i3DPrisms, iQuadratic );
667   addWidget( createField( this, Italic, "nbBiQuadraticPrism" ), i3DPrisms, iBiQuadratic );
668   // --+ hexagonal prisms
669   addWidget( createLabel( tr( "HEX_PRISMS_LAB" ), this, Italic ), i3DHexaPrisms, iLabel );
670   addWidget( createField( this, Italic, "nbHexagonalPrism" ), i3DHexaPrisms, iTotal );
671   // --+ polyhedrons
672   addWidget( createLabel( tr( "POLYHEDRONS_LAB" ), this, Italic ), i3DPolyhedrons, iLabel );
673   addWidget( createField( this, Italic, "nbPolyhedron" ), i3DPolyhedrons, iTotal );
674
675   // load button
676   QPushButton* loadBtn = new QPushButton( tr( "BUT_LOAD_MESH" ), this );
677   loadBtn->setAutoDefault( true );
678   connect( loadBtn, SIGNAL( clicked() ), this, SLOT( loadMesh() ) );
679   addWidget( loadBtn, iEnd, iSingle, 4 );
680
681   // additional layout set-up
682   l->setColumnStretch( iLabel, 0 );
683   l->setColumnStretch( iTotal, 5 );
684   l->setColumnStretch( iLinear, 5 );
685   l->setColumnStretch( iQuadratic, 5 );
686   l->setColumnStretch( iBiQuadratic, 5 );
687   l->setRowStretch( iElementsEnd, 5 );
688
689   // set initial values
690   clear();
691 }
692
693 /*!
694   \brief Destructor.
695 */
696 SMESHGUI_BaseInfo::~SMESHGUI_BaseInfo()
697 {
698 }
699
700 /*!
701   \brief Show information on given object.
702   \param proxy Object to show information on (mesh, sub-mesh, group, ID source).
703 */
704 void SMESHGUI_BaseInfo::showInfo( const SMESH::SelectionProxy& proxy )
705 {
706   // reset panel
707   clear();
708
709   // then fill panel with data if object is not null
710   if ( proxy )
711   {
712     myProxy = proxy;
713
714     SMESH::MeshInfo info = proxy.meshInfo();
715
716     // object info
717     // - name
718     widget( iName, iSingle )->setProperty( "text", proxy.name() );
719     // - type
720     QString typeName;
721     SMESH::SelectionProxy::Type type = proxy.type();
722     if ( type == SMESH::SelectionProxy::Mesh )
723     {
724       typeName = tr( "OBJECT_MESH" );
725     }
726     else if ( type == SMESH::SelectionProxy::Submesh )
727     {
728       typeName = tr( "OBJECT_SUBMESH" );
729     }
730     else if ( type >= SMESH::SelectionProxy::Group )
731     {
732       switch( proxy.groupElementType() )
733       {
734       case SMESH::NODE:   typeName = tr( "OBJECT_GROUP_NODES"   ); break;
735       case SMESH::EDGE:   typeName = tr( "OBJECT_GROUP_EDGES"   ); break;
736       case SMESH::FACE:   typeName = tr( "OBJECT_GROUP_FACES"   ); break;
737       case SMESH::VOLUME: typeName = tr( "OBJECT_GROUP_VOLUMES" ); break;
738       case SMESH::ELEM0D: typeName = tr( "OBJECT_GROUP_0DELEMS" ); break;
739       case SMESH::BALL:   typeName = tr( "OBJECT_GROUP_BALLS"   ); break;
740       default:            typeName = tr( "OBJECT_GROUP"         ); break;
741       }
742       QString subType;
743       if ( type == SMESH::SelectionProxy::GroupStd )
744         subType = tr( "OBJECT_GROUP_STANDALONE" );
745       else if ( type == SMESH::SelectionProxy::GroupGeom )
746         subType = tr( "OBJECT_GROUP_GEOM" );
747       else if ( type == SMESH::SelectionProxy::GroupFilter )
748         subType = tr( "OBJECT_GROUP_FILTER" );
749       if ( !subType.isEmpty() )
750         typeName = QString( "%1 %2" ).arg( typeName, subType );
751     }
752     widget( iObject, iSingle )->setProperty( "text", typeName );
753
754     // node info
755     uint nbNodes = info[SMDSEntity_Node];
756     widget( iNodes, iTotal )->setProperty( "value", nbNodes );
757
758     // element info
759     // - 0D elements info
760     uint nb0d = info[SMDSEntity_0D];
761     widget( i0D, iTotal )->setProperty( "value", nb0d );
762     // - balls info
763     uint nbBalls = info[SMDSEntity_Ball];
764     widget( iBalls, iTotal )->setProperty( "value", nbBalls );
765     // - 1D elements info
766     uint nb1dLin = info[SMDSEntity_Edge];
767     uint nb1dQua = info[SMDSEntity_Quad_Edge];
768     uint nb1d = nb1dLin + nb1dQua;
769     widget( i1D, iLinear )->setProperty( "value", nb1dLin );
770     widget( i1D, iQuadratic )->setProperty( "value", nb1dQua );
771     widget( i1D, iTotal )->setProperty( "value", nb1d );
772     // - 2D elements info
773     // --+ triangles
774     uint nbTriLin = info[SMDSEntity_Triangle];
775     uint nbTriQua = info[SMDSEntity_Quad_Triangle];
776     uint nbTriBiq = info[SMDSEntity_BiQuad_Triangle];
777     uint nbTri = nbTriLin + nbTriQua + nbTriBiq;
778     widget( i2DTriangles, iLinear )->setProperty( "value", nbTriLin );
779     widget( i2DTriangles, iQuadratic )->setProperty( "value", nbTriQua );
780     widget( i2DTriangles, iBiQuadratic )->setProperty( "value", nbTriBiq );
781     widget( i2DTriangles, iTotal )->setProperty( "value", nbTri );
782     // --+ quadrangles
783     uint nbQuadLin = info[SMDSEntity_Quadrangle];
784     uint nbQuadQua = info[SMDSEntity_Quad_Quadrangle];
785     uint nbQuadBiq = info[SMDSEntity_BiQuad_Quadrangle];
786     uint nbQuad = nbQuadLin + nbQuadQua + nbQuadBiq;
787     widget( i2DQuadrangles, iLinear )->setProperty( "value", nbQuadLin );
788     widget( i2DQuadrangles, iQuadratic )->setProperty( "value", nbQuadQua );
789     widget( i2DQuadrangles, iBiQuadratic )->setProperty( "value", nbQuadBiq );
790     widget( i2DQuadrangles, iTotal )->setProperty( "value", nbQuad );
791     // --+ polygons
792     uint nbPolyLin = info[SMDSEntity_Polygon];
793     uint nbPolyQua = info[SMDSEntity_Quad_Polygon];
794     uint nbPoly = nbPolyLin + nbPolyQua;
795     widget( i2DPolygons, iLinear )->setProperty( "value", nbPolyLin );
796     widget( i2DPolygons, iQuadratic )->setProperty( "value", nbPolyQua );
797     widget( i2DPolygons, iTotal )->setProperty( "value", nbPoly );
798     // --+ summary
799     uint nb2dLin = nbTriLin + nbQuadLin + nbPolyLin;
800     uint nb2dQua = nbTriQua + nbQuadQua + nbPolyQua;
801     uint nb2dBiq = nbTriBiq + nbQuadBiq;
802     uint nb2d = nb2dLin + nb2dQua + nb2dBiq;
803     widget( i2D, iLinear )->setProperty( "value", nb2dLin );
804     widget( i2D, iQuadratic )->setProperty( "value", nb2dQua );
805     widget( i2D, iBiQuadratic )->setProperty( "value", nb2dBiq );
806     widget( i2D, iTotal )->setProperty( "value", nb2d );
807     // - 3D elements info
808     // --+ tetras
809     uint nbTetraLin = info[SMDSEntity_Tetra];
810     uint nbTetraQua = info[SMDSEntity_Quad_Tetra];
811     uint nbTetra = nbTetraLin + nbTetraQua;
812     widget( i3DTetrahedrons, iLinear )->setProperty( "value", nbTetraLin );
813     widget( i3DTetrahedrons, iQuadratic )->setProperty( "value", nbTetraQua );
814     widget( i3DTetrahedrons, iTotal )->setProperty( "value", nbTetra );
815     // --+ hexas
816     uint nbHexaLin = info[SMDSEntity_Hexa];
817     uint nbHexaQua = info[SMDSEntity_Quad_Hexa];
818     uint nbHexaBiq = info[SMDSEntity_TriQuad_Hexa];
819     uint nbHexa = nbHexaLin + nbHexaQua + nbHexaBiq;
820     widget( i3DHexahedrons, iLinear )->setProperty( "value", nbHexaLin );
821     widget( i3DHexahedrons, iQuadratic )->setProperty( "value", nbHexaQua );
822     widget( i3DHexahedrons, iBiQuadratic )->setProperty( "value", nbHexaBiq );
823     widget( i3DHexahedrons, iTotal )->setProperty( "value", nbHexa );
824     // --+ pyramids
825     uint nbPyraLin = info[SMDSEntity_Pyramid];
826     uint nbPyraQua = info[SMDSEntity_Quad_Pyramid];
827     uint nbPyra = nbPyraLin + nbPyraQua;
828     widget( i3DPyramids, iLinear )->setProperty( "value", nbPyraLin );
829     widget( i3DPyramids, iQuadratic )->setProperty( "value", nbPyraQua );
830     widget( i3DPyramids, iTotal )->setProperty( "value", nbPyra );
831     // --+ prisms
832     uint nbPentaLin = info[SMDSEntity_Penta];
833     uint nbPentaQua = info[SMDSEntity_Quad_Penta];
834     uint nbPentaBiq = info[SMDSEntity_BiQuad_Penta];
835     uint nbPenta = nbPentaLin + nbPentaQua + nbPentaBiq;
836     widget( i3DPrisms, iLinear )->setProperty( "value", nbPentaLin );
837     widget( i3DPrisms, iQuadratic )->setProperty( "value", nbPentaQua );
838     widget( i3DPrisms, iBiQuadratic )->setProperty( "value", nbPentaBiq );
839     widget( i3DPrisms, iTotal )->setProperty( "value", nbPenta );
840     // --+ hexagonal prisms
841     uint nbHexaPri = info[SMDSEntity_Hexagonal_Prism];
842     widget( i3DHexaPrisms, iTotal )->setProperty( "value", nbHexaPri );
843     // --+ polyhedrons
844     uint nbPolyhedra = info[SMDSEntity_Polyhedra];
845     widget( i3DPolyhedrons, iTotal )->setProperty( "value", nbPolyhedra );
846     // --+ summary
847     uint nb3dLin = nbTetraLin + nbHexaLin + nbPyraLin + nbPentaLin + nbHexaPri + nbPolyhedra;
848     uint nb3dQua = nbTetraQua + nbHexaQua + nbPyraQua + nbPentaQua;
849     uint nb3dBiq = nbHexaBiq + nbPentaBiq;
850     uint nb3d = nb3dLin + nb3dQua + nb3dBiq;
851     widget( i3D, iLinear )->setProperty( "value", nb3dLin );
852     widget( i3D, iQuadratic )->setProperty( "value", nb3dQua );
853     widget( i3D, iBiQuadratic )->setProperty( "value", nb3dBiq );
854     widget( i3D, iTotal )->setProperty( "value", nb3d );
855     // - summary
856     uint nbElemLin = nb1dLin + nb2dLin + nb3dLin;
857     uint nbElemQua = nb1dQua + nb2dQua + nb3dQua;
858     uint nbElemBiq = nb2dBiq + nb3dBiq;
859     uint nbElem = nb0d + nbBalls + nb1d + nb2d + nb3d;
860     widget( iElementsTotal, iLinear )->setProperty( "value", nbElemLin );
861     widget( iElementsTotal, iQuadratic )->setProperty( "value", nbElemQua );
862     widget( iElementsTotal, iBiQuadratic )->setProperty( "value", nbElemBiq );
863     widget( iElementsTotal, iTotal )->setProperty( "value", nbElem );
864
865     // show 'Load' button if data was not loaded yet
866     widget( iEnd, iSingle )->setVisible( !proxy.isValid() );
867
868     // until data is loaded from study file, type of elements in a sub-mesh or group
869     // can be undefined in some cases
870     if ( !proxy.isValid() )
871     {
872       // two cases are possible:
873       // 1. type of 2D or 3D elements is unknown but their nb is OK (for a sub-mesh)
874       // 2. there is no info at all (for a group on geom or on filter)
875       if ( info.count( SMDSEntity_Node, SMDSEntity_Last ) > 0 ) // believe it is a sub-mesh
876       {
877         if ( nb2dLin + nb2dQua + nb2dBiq > 0 )
878         {
879           // we know nothing about triangles, quadranges and polygons
880           for ( int i = i2DTriangles; i < i2DEnd; i++ )
881           {
882             for ( int j = iTotal; j < iNbColumns; j++ )
883             {
884               if ( widget( i, j ) )
885                 widget( i, j )->setProperty( "text", "?" );
886             }
887           }
888           // we don't know if elements are linear, quadratic or bi-quadratic
889           for ( int j = iLinear; j < iNbColumns; j++ )
890           {
891             if ( widget( i2D, j ) )
892               widget( i2D, j )->setProperty( "text", "?" );
893             if ( widget( iElementsTotal, j ) )
894               widget( iElementsTotal, j )->setProperty( "text", "?" );
895           }
896         }
897         else if ( nb3dLin + nb3dQua + nb3dBiq > 0 )
898         {
899           // we know nothing about tetras, hexas, etc.
900           for ( int i = i3DTetrahedrons; i < i3DEnd; i++ )
901           {
902             for ( int j = iTotal; j < iNbColumns; j++ )
903             {
904               if ( widget( i, j ) )
905                 widget( i, j )->setProperty( "text", "?" );
906             }
907           }
908           // we don't know if elements are linear, quadratic or bi-quadratic
909           for ( int j = iLinear; j < iNbColumns; j++ )
910           {
911             if ( widget( i3D, j ) )
912               widget( i3D, j )->setProperty( "text", "?" );
913             if ( widget( iElementsTotal, j ) )
914               widget( iElementsTotal, j )->setProperty( "text", "?" );
915           }
916         }
917       }
918       else
919       {
920         // we know nothing about nodes :(
921         widget( iNodes, iTotal )->setProperty( "text", "?" );
922         // we know nothing about elements :(
923         for ( int i = iElementsTotal; i < iElementsEnd; i++ )
924         {
925           for ( int j = iTotal; j < iNbColumns; j++ )
926           {
927             if ( widget( i, j ) )
928               widget( i, j )->setProperty( "text", "?" );
929           }
930         }
931       }
932     }
933   }
934 }
935
936 /*!
937   \brief Update information in panel.
938 */
939 void SMESHGUI_BaseInfo::updateInfo()
940 {
941   showInfo( myProxy );
942 }
943
944 /*!
945   \brief Load mesh from a study file.
946 */
947 void SMESHGUI_BaseInfo::loadMesh()
948 {
949   SUIT_OverrideCursor wc;
950   if ( myProxy )
951   {
952     myProxy.load();
953     updateInfo();
954   }
955 }
956
957 /*!
958   \brief Reset panel (clear all data).
959 */
960 void SMESHGUI_BaseInfo::clear()
961 {
962   // - name
963   widget( iName, iSingle )->setProperty( "text", QString() );
964   // - type
965   widget( iObject, iSingle )->setProperty( "text", QString() );
966   // - nodes
967   widget( iNodes, iTotal )->setProperty( "value", 0 );
968   // - elements
969   for ( int i = iElementsTotal; i < iElementsEnd; i++ )
970   {
971     for ( int j = iTotal; j < iNbColumns; j++ )
972     {
973       if ( widget( i, j ) )
974         widget( i, j )->setProperty( "value", 0 );
975     }
976   }
977   // hide 'Load' button
978   widget( iEnd, iSingle )->setVisible( false );
979 }
980
981 /*!
982   \brief Register widget in a grid.
983   \param w Widget being added.
984   \param row Row index in a grid.
985   \param column Column index in a grid.
986   \param colspan Number of columns to span in a grid. Defaults to 1.
987   \return Just added widget.
988 */
989 QWidget* SMESHGUI_BaseInfo::addWidget( QWidget* w, int row, int column, int colspan )
990 {
991   if ( !myWidgets.contains( row ) )
992     myWidgets[row] = wlist();
993   myWidgets[row][column] = w;
994   dynamic_cast<QGridLayout*>( layout() )->addWidget( w, row, column, 1, colspan );
995   return w;
996 }
997
998 /*!
999   \brief Get registered widget.
1000   \param row Row index in a grid.
1001   \param column Column index in a grid.
1002   \return Widget stored in a given grid cell (0 if there's no widget).
1003 */
1004 QWidget* SMESHGUI_BaseInfo::widget( int row, int column ) const
1005 {
1006   return myWidgets.contains( row ) && myWidgets[row].contains( column ) ? myWidgets[row][column] : 0;
1007 }
1008
1009 /*!
1010   \brief Get text value from registered widget.
1011   \param row Row index in a grid.
1012   \param column Column index in a grid.
1013   \return Value string (empty string if no label in given cell).
1014 */
1015 QString SMESHGUI_BaseInfo::value( int row, int column ) const
1016 {
1017   return widgetValue( widget( row, column ) );
1018 }
1019
1020 /*!
1021   \brief Show/hide group(s) of widgets.
1022   \param startRow Starting grid row.
1023   \param lastRow Last grid row.
1024   \param on Visibility flag.
1025 */
1026 void SMESHGUI_BaseInfo::setFieldsVisible( int startRow, int lastRow, bool on )
1027 {
1028   startRow = qMax( 0, startRow );
1029   lastRow = qMin( lastRow, (int)iEnd );
1030   for ( int i = startRow; i <= lastRow; i++ )
1031   {
1032     wlist widgets = myWidgets[i];
1033     foreach ( QWidget* w, widgets )
1034       w->setVisible( on );
1035   }
1036 }
1037
1038 /*!
1039   \brief Write information from panel to ouput stream.
1040   \param out Text stream output.
1041 */
1042 void SMESHGUI_BaseInfo::saveInfo( QTextStream& out )
1043 {
1044   // title
1045   QString title = tr( "BASE_INFO" );
1046   out << ruler( title.size() ) << endl;
1047   out << title << endl;
1048   out << ruler( title.size() ) << endl;
1049   out << endl;
1050
1051   // object info
1052   // - name
1053   out << tr( "NAME_LAB" ) << spacing() << value( iName, iSingle ) << endl;
1054   // - type
1055   out << tr( "OBJECT_LAB" ) << spacing() << value( iObject, iSingle ) << endl;
1056   // - --- (separator)
1057   out << endl;
1058
1059   // node info
1060   out << tr( "NODES_LAB" ) << spacing() << value( iNodes, iTotal ) << endl;
1061   // - --- (separator)
1062   out << endl;
1063
1064   // element info
1065   QString lin = tr( "LINEAR_LAB" ) + ":" + spacing();
1066   QString qua = tr( "QUADRATIC_LAB" ) + ":" + spacing();
1067   QString biq = tr( "BI_QUADRATIC_LAB" ) + ":" + spacing();
1068   // - summary
1069   out << tr( "ELEMENTS_LAB" ) << spacing() << value( iElementsTotal, iTotal ) << endl;
1070   out << indent(1) << lin << value( iElementsTotal, iLinear ) << endl;
1071   out << indent(1) << qua << value( iElementsTotal, iQuadratic ) << endl;
1072   out << indent(1) << biq << value( iElementsTotal, iBiQuadratic ) << endl;
1073   // - --- (separator)
1074   out << endl;
1075   // - 0D elements info
1076   out << indent(1) << tr( "0D_LAB" ) << spacing() << value( i0D, iTotal ) << endl;
1077   // - --- (separator)
1078   out << endl;
1079   // - balls info
1080   out << indent(1) << tr( "BALL_LAB" ) << spacing() << value( iBalls, iTotal ) << endl;
1081   // - --- (separator)
1082   out << endl;
1083   // - 1D elements info
1084   out << indent(1) << tr( "1D_LAB" ) << spacing() << value( i1D, iTotal ) << endl;
1085   out << indent(2) << lin << value( i1D, iLinear ) << endl;
1086   out << indent(2) << qua << value( i1D, iQuadratic ) << endl;
1087   // - --- (separator)
1088   out << endl;
1089   // - 2D elements info
1090   // - summary
1091   out << indent(1) << tr( "2D_LAB" ) << spacing() << value( i2D, iTotal ) << endl;
1092   out << indent(2) << lin << value( i2D, iLinear ) << endl;
1093   out << indent(2) << qua << value( i2D, iQuadratic ) << endl;
1094   out << indent(2) << biq << value( i2D, iBiQuadratic ) << endl;
1095   // - --- (separator)
1096   out << endl;
1097   // --+ triangles
1098   out << indent(2) << tr( "TRIANGLES_LAB" ) << spacing() << value( i2DTriangles, iTotal ) << endl;
1099   out << indent(3) << lin << value( i2DTriangles, iLinear ) << endl;
1100   out << indent(3) << qua << value( i2DTriangles, iQuadratic ) << endl;
1101   out << indent(3) << biq << value( i2DTriangles, iBiQuadratic ) << endl;
1102   // --+ quadrangles
1103   out << indent(2) << tr( "QUADRANGLES_LAB" ) << spacing() << value( i2DQuadrangles, iTotal ) << endl;
1104   out << indent(3) << lin << value( i2DQuadrangles, iLinear ) << endl;
1105   out << indent(3) << qua << value( i2DQuadrangles, iQuadratic ) << endl;
1106   out << indent(3) << biq << value( i2DQuadrangles, iBiQuadratic ) << endl;
1107   // --+ polygons
1108   out << indent(2) << tr( "POLYGONS_LAB" ) << spacing() << value( i2DPolygons, iTotal ) << endl;
1109   out << indent(3) << lin << value( i2DPolygons, iLinear ) << endl;
1110   out << indent(3) << qua << value( i2DPolygons, iQuadratic ) << endl;
1111   // - --- (separator)
1112   out << endl;
1113   // - 3D elements info
1114   // --+ summary
1115   out << indent(1) << tr( "3D_LAB" ) << spacing() << value( i3D, iTotal ) << endl;
1116   out << indent(2) << lin << value( i3D, iLinear ) << endl;
1117   out << indent(2) << qua << value( i3D, iQuadratic ) << endl;
1118   out << indent(2) << biq << value( i3D, iBiQuadratic ) << endl;
1119   // - --- (separator)
1120   out << endl;
1121   // --+ tetras
1122   out << indent(2) << tr( "TETRAHEDRONS_LAB" ) << spacing() << value( i3DTetrahedrons, iTotal ) << endl;
1123   out << indent(3) << lin << value( i3DTetrahedrons, iLinear ) << endl;
1124   out << indent(3) << qua << value( i3DTetrahedrons, iQuadratic ) << endl;
1125   // --+ hexas
1126   out << indent(2) << tr( "HEXAHEDONRS_LAB" ) << spacing() << value( i3DHexahedrons, iTotal ) << endl;
1127   out << indent(3) << lin << value( i3DHexahedrons, iLinear ) << endl;
1128   out << indent(3) << qua << value( i3DHexahedrons, iQuadratic ) << endl;
1129   out << indent(3) << biq << value( i3DHexahedrons, iBiQuadratic ) << endl;
1130   // --+ pyramids
1131   out << indent(2) << tr( "PYRAMIDS_LAB" ) << spacing() << value( i3DPyramids, iTotal ) << endl;
1132   out << indent(3) << lin << value( i3DPyramids, iLinear ) << endl;
1133   out << indent(3) << qua << value( i3DPyramids, iQuadratic ) << endl;
1134   // --+ prisms
1135   out << indent(2) << tr( "PRISMS_LAB" ) << spacing() << value( i3DPrisms, iTotal ) << endl;
1136   out << indent(3) << lin << value( i3DPrisms, iLinear ) << endl;
1137   out << indent(3) << qua << value( i3DPrisms, iQuadratic ) << endl;
1138   out << indent(3) << biq << value( i3DPrisms, iBiQuadratic ) << endl;
1139   // --+ hexagonal prisms
1140   out << indent(2) << tr( "HEX_PRISMS_LAB" ) << spacing() << value( i3DHexaPrisms, iTotal ) << endl;
1141   // --+ polyhedrons
1142   out << indent(2) << tr( "POLYHEDRONS_LAB" ) << spacing() << value( i3DPolyhedrons, iTotal ) << endl;
1143   // - --- (separator)
1144   out << endl;
1145 }
1146
1147 ////////////////////////////////////////////////////////////////////////////////
1148 /// \class InfoWriter
1149 /// \brief Base info writer class.
1150 /// \internal
1151 ////////////////////////////////////////////////////////////////////////////////
1152
1153 class InfoWriter
1154 {
1155 protected:
1156   int myPrecision;
1157   bool myRecursive;
1158 public:
1159   InfoWriter( bool = false );
1160   void write( const QString&, bool = false );
1161   void write( const QString&, const QString&, bool = false );
1162   void write( const QString&, int, bool = false );
1163   void write( const QString&, double, bool = false );
1164   void write( const QString&, const SMESH::XYZ&, bool = false );
1165   virtual void indent() {}
1166   virtual void unindent() {}
1167   virtual void separator() {}
1168 protected:
1169   virtual void put( const QString&, const QString&, bool = false ) = 0;
1170 };
1171
1172 InfoWriter::InfoWriter( bool r ): myRecursive(r)
1173 {
1174   myPrecision = SMESHGUI::resourceMgr()->integerValue( "SMESH", "length_precision", 6 );
1175 }
1176
1177 void InfoWriter::write( const QString& key, bool emphasize )
1178 {
1179   put( key, QString(), emphasize );
1180 }
1181
1182 void InfoWriter::write( const QString& key, const QString& value, bool emphasize )
1183 {
1184   put( key, value, emphasize );
1185 }
1186
1187 void InfoWriter::write( const QString& key, int value, bool emphasize )
1188 {
1189   put( key, QString::number( value ), emphasize );
1190 }
1191
1192 void InfoWriter::write( const QString& key, double value, bool emphasize )
1193 {
1194   put( key, QString::number( value, myPrecision > 0 ? 'f' : 'g', qAbs( myPrecision ) ), emphasize );
1195 }
1196
1197 void InfoWriter::write( const QString& key, const SMESH::XYZ& value, bool emphasize )
1198 {
1199   if ( myRecursive )
1200   {
1201     write( key, emphasize );
1202     indent();
1203     write( "X", value.x() );
1204     write( "Y", value.y() );
1205     write( "Z", value.z() );
1206     unindent(); 
1207   }
1208   else
1209   {
1210     QStringList vl;
1211     vl << QString::number( value.x(), myPrecision > 0 ? 'f' : 'g', qAbs( myPrecision ) );
1212     vl << QString::number( value.y(), myPrecision > 0 ? 'f' : 'g', qAbs( myPrecision ) );
1213     vl << QString::number( value.z(), myPrecision > 0 ? 'f' : 'g', qAbs( myPrecision ) );
1214     put( key, vl.join( ", " ), emphasize );
1215   }
1216 }
1217
1218 ////////////////////////////////////////////////////////////////////////////////
1219 /// \class SimpleWriter
1220 /// \brief Base text writer.
1221 /// \internal
1222 ////////////////////////////////////////////////////////////////////////////////
1223
1224 class SimpleWriter: public InfoWriter
1225 {
1226 protected:
1227   int myIndent;
1228 public:
1229   SimpleWriter();
1230   void indent();
1231   void unindent();
1232   void separator();
1233 protected:
1234   void put( const QString&, const QString&, bool );
1235   virtual QString spacer() const;
1236   virtual QString decorate( const QString& ) const;
1237   virtual void dumpLine( const QString& ) = 0;
1238 };
1239
1240 SimpleWriter::SimpleWriter(): InfoWriter(false), myIndent(0)
1241 {
1242 }
1243
1244 void SimpleWriter::indent()
1245 {
1246   myIndent += 1;
1247 }
1248
1249 void SimpleWriter::unindent()
1250 {
1251   myIndent = qMax( myIndent-1, 0 );
1252 }
1253
1254 void SimpleWriter::separator()
1255 {
1256   write( "" );
1257 }
1258
1259 QString SimpleWriter::spacer() const
1260 {
1261   return " ";
1262 }
1263
1264 QString SimpleWriter::decorate( const QString& s ) const
1265 {
1266   return s;
1267 }
1268
1269 void SimpleWriter::put( const QString& key, const QString& value, bool emphasize )
1270 {
1271   QString line;
1272   line += ::indent( spacer(), myIndent*4 );
1273   line += decorate( key );
1274   if ( !value.isEmpty() )
1275   {
1276     line += ":";
1277     line += emphasize ? decorate( value ) : value;
1278   }
1279   dumpLine( line );
1280 }
1281
1282 ////////////////////////////////////////////////////////////////////////////////
1283 /// \class StreamWriter
1284 /// \brief Writer for QTextStream.
1285 /// \internal
1286 ////////////////////////////////////////////////////////////////////////////////
1287
1288 class StreamWriter: public SimpleWriter
1289 {
1290   QTextStream& myOut;
1291 public:
1292   StreamWriter( QTextStream& );
1293 protected:
1294   void dumpLine( const QString& );
1295 };
1296
1297 StreamWriter::StreamWriter( QTextStream& out ): SimpleWriter(), myOut(out)
1298 {
1299 }
1300
1301 void StreamWriter::dumpLine( const QString& line )
1302 {
1303   myOut << line;
1304   myOut << endl;
1305 }
1306
1307 ////////////////////////////////////////////////////////////////////////////////
1308 /// \class TextWriter
1309 /// \brief Writer for QTextBrowser.
1310 /// \internal
1311 ////////////////////////////////////////////////////////////////////////////////
1312
1313 class TextWriter: public SimpleWriter
1314 {
1315   QTextBrowser* myInfo;
1316 public:
1317   TextWriter( QTextBrowser* );
1318 protected:
1319   QString spacer() const;
1320   QString decorate( const QString& ) const;
1321   void dumpLine( const QString& );
1322 };
1323
1324 TextWriter::TextWriter( QTextBrowser* w ): SimpleWriter(), myInfo(w)
1325 {
1326 }
1327
1328 QString TextWriter::spacer() const
1329 {
1330   return "&nbsp;";
1331 }
1332
1333 QString TextWriter::decorate( const QString& s ) const
1334 {
1335   return bold( s );
1336 }
1337
1338 void TextWriter::dumpLine( const QString& line )
1339 {
1340   myInfo->append( line );
1341 }
1342
1343 ////////////////////////////////////////////////////////////////////////////////
1344 /// \class TreeWriter
1345 /// \brief Writer for QTreeWidget.
1346 /// \internal
1347 ////////////////////////////////////////////////////////////////////////////////
1348
1349 class TreeWriter: public InfoWriter
1350 {
1351   QTreeWidget* myInfo;
1352   QTreeWidgetItem* myCurrentItem;
1353   TreeItemCreator* myCreator;
1354 public:
1355   TreeWriter( QTreeWidget*, TreeItemCreator* );
1356   ~TreeWriter();
1357   void indent();
1358   void unindent();
1359 protected:
1360   void put( const QString&, const QString&, bool = false );
1361 };
1362
1363 TreeWriter::TreeWriter( QTreeWidget* w, TreeItemCreator* c ):
1364   InfoWriter(true), myInfo(w), myCurrentItem(0), myCreator(c)
1365 {
1366 }
1367
1368 TreeWriter::~TreeWriter()
1369 {
1370   delete myCreator;
1371 }
1372
1373 void TreeWriter::put( const QString& key, const QString& value, bool emphasize )
1374 {
1375   //std::string sss = myCurrentItem ? myCurrentItem->text(0).toStdString() : "";
1376   int options = Bold;
1377   if ( emphasize ) options |= AllColumns;
1378   QTreeWidgetItem* item = myCreator->createItem( myCurrentItem, options );
1379   item->setText( 0, key );
1380   if ( !value.isEmpty() )
1381   {
1382     QString val = value;
1383     if ( value.startsWith( "<a href" )) // connectivity encoded as: <a href = "nodes://host/1 2">1 2</a>
1384     {
1385       int role = ( value[11] == 'n' ) ? NodeConnectivity : ElemConnectivity;
1386       val = value.mid( value.lastIndexOf( '>', -5 ) + 1 ); // ==>   1 2</a>
1387       val.chop( 4 );
1388       item->setData( 1, TypeRole, role );
1389     }
1390     item->setText( 1, val );
1391   }
1392 }
1393
1394 void TreeWriter::indent()
1395 {
1396   QTreeWidgetItem* item = myCurrentItem ? myCurrentItem : myInfo->invisibleRootItem();
1397   if ( item->childCount() > 0 )
1398     myCurrentItem = item->child( item->childCount()-1 );
1399 }
1400
1401 void TreeWriter::unindent()
1402 {
1403   if ( myCurrentItem )
1404     myCurrentItem = myCurrentItem->parent();
1405 }
1406
1407 ////////////////////////////////////////////////////////////////////////////////
1408 /// \class SMESHGUI_ElemInfo
1409 /// \brief Base class for the mesh element information widget.
1410 ///
1411 /// Displays the detail information about given mesh node(s) or element(s).
1412 /// Default class does not provide working implementation but onle general
1413 /// functionalities; main work is done in sub-classes.
1414 ////////////////////////////////////////////////////////////////////////////////
1415
1416 /*!
1417   \brief Constructor.
1418   \param parent Parent widget. Defaults to 0.
1419 */
1420 SMESHGUI_ElemInfo::SMESHGUI_ElemInfo( QWidget* parent ): SMESHGUI_Info( parent ), myWhat( ShowNone )
1421 {
1422   myFrame = new QWidget( this );
1423   myExtra = new ExtraWidget( this );
1424
1425   QVBoxLayout* vbl = new QVBoxLayout( this );
1426   vbl->setMargin( 0 );
1427   vbl->setSpacing( SPACING );
1428   vbl->addWidget( myFrame );
1429   vbl->addWidget( myExtra );
1430
1431   connect( myExtra->prev, SIGNAL( clicked() ), this, SLOT( showPrevious() ) );
1432   connect( myExtra->next, SIGNAL( clicked() ), this, SLOT( showNext() ) );
1433
1434   clear();
1435 }
1436
1437 /*!
1438   \brief Destructor.
1439 */
1440 SMESHGUI_ElemInfo::~SMESHGUI_ElemInfo()
1441 {
1442 }
1443
1444 /*!
1445   \brief Show information on given node / element.
1446   \param proxy Object to compute information on (mesh, sub-mesh, group, ID source).
1447   \param id Mesh node / element ID.
1448   \param isElement If \c true, show element info; otherwise show node info.
1449 */
1450 void SMESHGUI_ElemInfo::showInfo( const SMESH::SelectionProxy& proxy, uint id, bool isElement )
1451 {
1452   QSet<uint> ids;
1453   ids << id;
1454   showInfo( proxy, ids, isElement );
1455 }
1456
1457 /*!
1458   \brief Show information on given nodes / elements.
1459   \param proxy Object to compute information on (mesh, sub-mesh, group, ID source).
1460   \param ids Mesh nodes / elements IDs.
1461   \param isElement If \c true, show element info; otherwise show node info.
1462 */
1463 void SMESHGUI_ElemInfo::showInfo( const SMESH::SelectionProxy& proxy, QSet<uint> ids, bool isElement )
1464 {
1465   if ( !proxy )
1466   {
1467     clear();
1468     return;
1469   }
1470
1471   QList<uint> newIds = ids.toList();
1472   qSort( newIds );
1473   int what = isElement ? ShowElements : ShowNodes;
1474   
1475   if ( myProxy == proxy && myIDs == newIds && myWhat == what )
1476     return;
1477   
1478   myProxy = proxy;
1479   myProxy.refresh(); // try to re-initialize actor
1480
1481   clear();
1482
1483   myIDs = newIds;
1484   myWhat = what;
1485   myIndex = 0;
1486   
1487   updateControls();
1488   information( myIDs.mid( myIndex*blockSize(), blockSize() ) );
1489 }
1490
1491 /*!
1492   \brief Show information on given group.
1493   \param proxy Object to compute information on (group).
1494 */
1495 void SMESHGUI_ElemInfo::showInfo( const SMESH::SelectionProxy& proxy )
1496 {
1497   if ( !proxy || proxy.groupElementType() == SMESH::ALL ) // null proxy or not a group
1498   {
1499     clear();
1500     return;
1501   }
1502
1503   showInfo( proxy, proxy.ids(), proxy.groupElementType() != SMESH::NODE );
1504 }
1505
1506 /*!
1507   \brief Reset panel (clear all data).
1508 */
1509 void SMESHGUI_ElemInfo::clear()
1510 {
1511   myIDs.clear();
1512   myIndex = 0;
1513   clearInternal();
1514   updateControls();
1515 }
1516
1517 /*!
1518   \brief Get central area widget.
1519   \return Central widget.
1520 */
1521 QWidget* SMESHGUI_ElemInfo::centralWidget() const
1522 {
1523   return myFrame;
1524 }
1525
1526 /*!
1527   \brief Get current mesh proxy object information is shown on.
1528   \return Current proxy.
1529 */
1530 SMESH::SelectionProxy SMESHGUI_ElemInfo::proxy() const
1531 {
1532   return myProxy;
1533 }
1534
1535 /*!
1536   \brief Get current info mode.
1537   \return Current panel mode.
1538 */
1539 int SMESHGUI_ElemInfo::what() const
1540 {
1541   return myWhat;
1542 }
1543
1544 /*!
1545   \brief Get title for given element type.
1546   \param type Mesh element type.
1547   \param multiple Use plural form. Defaults to \c false.
1548   \return Element type's title.
1549 */
1550 QString SMESHGUI_ElemInfo::type2str( int type, bool multiple )
1551 {
1552   QString title;
1553   switch ( type )
1554   {
1555   case SMDSAbs_Edge:
1556     title = multiple ? tr( "EDGES" ) : tr( "EDGE" ) ; break;
1557   case SMDSAbs_Face:
1558     title = multiple ? tr( "FACES" ) : tr( "FACE" ); break;
1559   case SMDSAbs_Volume:
1560     title = multiple ? tr( "VOLUMES" ) : tr( "VOLUME" ); break;
1561   case SMDSAbs_0DElement:
1562     title = multiple ? tr( "0D_ELEMENTS" ) : tr( "0D_ELEMENT" ); break;
1563   case SMDSAbs_Ball:
1564     title = multiple ? tr( "BALL_ELEMENTS" ) : tr( "BALL" ); break;
1565   default:
1566     break;
1567   }
1568   return title;
1569 }
1570
1571 /*!
1572   \brief Get title for given shape type.
1573   \param type Shape type.
1574   \return Shape type's title.
1575 */
1576 QString SMESHGUI_ElemInfo::stype2str( int type )
1577 {
1578   QString title;
1579   switch ( type )
1580   {
1581   case GEOM::VERTEX:
1582     title = tr( "GEOM_VERTEX" ); break;
1583   case GEOM::EDGE:
1584     title = tr( "GEOM_EDGE" ); break;
1585   case GEOM::FACE:
1586     title = tr( "GEOM_FACE" ); break;
1587   case GEOM::SOLID:
1588   default:
1589     title = tr( "GEOM_SOLID" ); break;
1590     break;
1591   }
1592   return title;
1593 }
1594
1595 /*!
1596   \brief Get title for given element type.
1597   \param type Mesh element type.
1598   \return Element type's title.
1599 */
1600 QString SMESHGUI_ElemInfo::etype2str( int type )
1601 {
1602   QString title;
1603   switch ( type )
1604   {
1605   case SMESH::Entity_0D:
1606     title = tr( "SMESH_ELEM0D" ); break;
1607   case SMESH::Entity_Edge:
1608     title = tr( "SMESH_EDGE" ); break;
1609   case SMESH::Entity_Quad_Edge:
1610     title = tr( "SMESH_QUADRATIC_EDGE" ); break;
1611   case SMESH::Entity_Triangle:
1612     title = tr( "SMESH_TRIANGLE" ); break;
1613   case SMESH::Entity_Quad_Triangle:
1614     title = tr( "SMESH_QUADRATIC_TRIANGLE" ); break;
1615   case SMESH::Entity_BiQuad_Triangle:
1616     title = tr( "SMESH_BIQUADRATIC_TRIANGLE" ); break;
1617   case SMESH::Entity_Quadrangle:
1618     title = tr( "SMESH_QUADRANGLE" ); break;
1619   case SMESH::Entity_Quad_Quadrangle:
1620     title = tr( "SMESH_QUADRATIC_QUADRANGLE" ); break;
1621   case SMESH::Entity_BiQuad_Quadrangle:
1622     title = tr( "SMESH_BIQUADRATIC_QUADRANGLE" ); break;
1623   case SMESH::Entity_Polygon:
1624     title = tr( "SMESH_POLYGON" ); break;
1625   case SMESH::Entity_Quad_Polygon:
1626     title = tr( "SMESH_QUADRATIC_POLYGON" ); break;
1627   case SMESH::Entity_Tetra:
1628     title = tr( "SMESH_TETRAHEDRON" ); break;
1629   case SMESH::Entity_Quad_Tetra:
1630     title = tr( "SMESH_QUADRATIC_TETRAHEDRON" ); break;
1631   case SMESH::Entity_Pyramid:
1632     title = tr( "SMESH_PYRAMID" ); break;
1633   case SMESH::Entity_Quad_Pyramid:
1634     title = tr( "SMESH_QUADRATIC_PYRAMID" ); break;
1635   case SMESH::Entity_Hexa:
1636     title = tr( "SMESH_HEXAHEDRON" ); break;
1637   case SMESH::Entity_Quad_Hexa:
1638     title = tr( "SMESH_QUADRATIC_HEXAHEDRON" ); break;
1639   case SMESH::Entity_TriQuad_Hexa:
1640     title = tr( "SMESH_TRIQUADRATIC_HEXAHEDRON" ); break;
1641   case SMESH::Entity_Penta:
1642     title = tr( "SMESH_PENTA" ); break;
1643   case SMESH::Entity_Quad_Penta:
1644     title = tr( "SMESH_QUADRATIC_PENTAHEDRON" ); break;
1645   case SMESH::Entity_BiQuad_Penta:
1646     title = tr( "SMESH_BIQUADRATIC_PENTAHEDRON" ); break;
1647   case SMESH::Entity_Hexagonal_Prism:
1648     title = tr( "SMESH_HEX_PRISM" ); break;
1649   case SMESH::Entity_Polyhedra:
1650     title = tr( "SMESH_POLYEDRON" ); break;
1651   case SMESH::Entity_Quad_Polyhedra:
1652     title = tr( "SMESH_QUADRATIC_POLYEDRON" ); break;
1653   case SMESH::Entity_Ball:
1654     title = tr( "SMESH_BALL" ); break;
1655   default:
1656     break;
1657   }
1658   return title;
1659 }
1660
1661 /*!
1662   \brief Get title for given quality control.
1663   \param type Mesh control type.
1664   \return Quality control's title.
1665 */
1666 QString SMESHGUI_ElemInfo::ctrl2str( int control )
1667 {
1668   QString title;
1669   switch ( control )
1670   {
1671   case SMESH::FT_AspectRatio:
1672     title = tr( "ASPECTRATIO_ELEMENTS" ); break;
1673   case SMESH::FT_AspectRatio3D:
1674     title = tr( "ASPECTRATIO_3D_ELEMENTS" ); break;
1675   case SMESH::FT_Warping:
1676     title = tr( "WARP_ELEMENTS" ); break;
1677   case SMESH::FT_MinimumAngle:
1678     title = tr( "MINIMUMANGLE_ELEMENTS" ); break;
1679   case SMESH::FT_Taper:
1680     title = tr( "TAPER_ELEMENTS" ); break;
1681   case SMESH::FT_Skew:
1682     title = tr( "SKEW_ELEMENTS" ); break;
1683   case SMESH::FT_Area:
1684     title = tr( "AREA_ELEMENTS" ); break;
1685   case SMESH::FT_Volume3D:
1686     title = tr( "VOLUME_3D_ELEMENTS" ); break;
1687   case SMESH::FT_MaxElementLength2D:
1688     title = tr( "MAX_ELEMENT_LENGTH_2D" ); break;
1689   case SMESH::FT_MaxElementLength3D:
1690     title = tr( "MAX_ELEMENT_LENGTH_3D" ); break;
1691   case SMESH::FT_Length:
1692     title = tr( "LENGTH_EDGES" ); break;
1693   case SMESH::FT_Length2D:
1694   case SMESH::FT_Length3D:
1695     title = tr( "MIN_ELEM_EDGE" ); break;
1696   case SMESH::FT_BallDiameter:
1697     title = tr( "BALL_DIAMETER" ); break;
1698   default:
1699     break;
1700   }
1701   return title;
1702 }
1703
1704 /*!
1705   \brief Write information on given mesh nodes / elements.
1706   \param writer Information writer.
1707   \param ids Nodes / elements IDs.
1708 */
1709 void SMESHGUI_ElemInfo::writeInfo( InfoWriter* writer, const QList<uint>& ids )
1710 {
1711   if ( !proxy() )
1712     return;
1713
1714   bool grp_details = SMESHGUI::resourceMgr()->booleanValue( "SMESH", "elem_info_grp_details", false );
1715   int cprecision = SMESHGUI::resourceMgr()->booleanValue( "SMESH", "use_precision", false ) ? 
1716     SMESHGUI::resourceMgr()->integerValue( "SMESH", "controls_precision", -1 ) : -1;
1717
1718   SMESH::XYZ xyz;
1719   SMESH::Connectivity connectivity;
1720   SMESH::Position position;
1721   bool ok;
1722
1723   foreach ( uint id, ids )
1724   {
1725     writer->separator();
1726
1727     if ( what() == ShowNodes )
1728     {
1729       // show node info
1730       // - check that node exists
1731       if ( !proxy().hasNode( id ) )
1732         continue;
1733       // - id
1734       writer->write( tr( "NODE" ), (int)id, true );
1735       writer->indent();
1736       // - coordinates
1737       ok = proxy().nodeCoordinates( id, xyz );
1738       if ( ok )
1739       {
1740         writer->write( tr( "COORDINATES" ), xyz );
1741       }
1742       // - connectivity
1743       ok = proxy().nodeConnectivity( id, connectivity );
1744       if ( ok )
1745       {
1746         if ( !connectivity.isEmpty() )
1747         {
1748           writer->write( tr( "CONNECTIVITY" ) );
1749           writer->indent();
1750           for ( int i = SMDSAbs_Edge; i <= SMDSAbs_Ball; i++ )
1751           {
1752             QString formatted = formatConnectivity( connectivity, i );
1753             if ( !formatted.isEmpty() )
1754               writer->write( type2str( i, true ), formatted );
1755           }
1756           writer->unindent();
1757         }
1758         else
1759         {
1760           writer->write( tr( "CONNECTIVITY" ), tr( "FREE_NODE" ) );
1761         }
1762       }
1763       // - position
1764       ok = proxy().nodePosition( id, position );
1765       if ( ok && position.isValid() )
1766       {
1767         writer->write( tr( "POSITION" ), (stype2str( position.shapeType() ) + " #%1").arg( position.shapeId() ) );
1768         writer->indent();
1769         if ( position.hasU() )
1770           writer->write( tr("U_POSITION"), position.u() );
1771         if ( position.hasV() )
1772           writer->write( tr("V_POSITION"), position.v() );
1773         writer->unindent();
1774       }
1775       // - groups node belongs to
1776       QList<SMESH::SelectionProxy> groups = proxy().nodeGroups( id );
1777       bool topCreated = false;
1778       foreach( SMESH::SelectionProxy group, groups )
1779       {
1780         if ( group && !group.name().isEmpty() )
1781         {
1782           if ( !topCreated )
1783           {
1784             writer->write( SMESHGUI_AddInfo::tr( "GROUPS" ) );
1785             writer->indent();
1786             topCreated = true;
1787           }
1788           writer->write( group.name().trimmed() ); // trim name
1789           if ( grp_details )
1790           {
1791             writer->indent();
1792             int type = group.type();
1793             if ( type == SMESH::SelectionProxy::GroupStd )
1794             {
1795               writer->write( SMESHGUI_AddInfo::tr( "TYPE" ), SMESHGUI_AddInfo::tr( "STANDALONE_GROUP" ) );
1796             }
1797             else if ( type == SMESH::SelectionProxy::GroupGeom )
1798             {
1799               writer->write( SMESHGUI_AddInfo::tr( "TYPE" ), SMESHGUI_AddInfo::tr( "GROUP_ON_GEOMETRY" ) );
1800               writer->write( SMESHGUI_AddInfo::tr( "GEOM_OBJECT" ), group.shapeName() );
1801             }
1802             else if ( type == SMESH::SelectionProxy::GroupFilter )
1803             {
1804               writer->write( SMESHGUI_AddInfo::tr( "TYPE" ), SMESHGUI_AddInfo::tr( "GROUP_ON_FILTER" ) );
1805             }
1806             int size = group.size();
1807             if ( size != -1 );
1808             writer->write( SMESHGUI_AddInfo::tr( "SIZE" ), size );
1809             QColor color = group.color();
1810             if ( color.isValid() )
1811               writer->write( SMESHGUI_AddInfo::tr( "COLOR" ), color.name() );
1812             writer->unindent();
1813           }
1814         }
1815       }
1816       if ( topCreated )
1817         writer->unindent();
1818       writer->unindent();
1819     }
1820     else if ( what() == ShowElements )
1821     {
1822       // show element info
1823       // - check that element exists
1824       if ( !proxy().hasElement( id ) )
1825         continue;
1826       // - id & type
1827       int type = proxy().elementType( id );
1828       if  ( type == SMESH::ALL )
1829         continue;
1830       writer->write( type2str( type ), (int)id, true );
1831       writer->indent();
1832       // - geometry type
1833       type = proxy().elementEntityType( id );
1834       writer->write( tr( "TYPE" ), etype2str( type ) );
1835       // - connectivity
1836       if ( type == SMESH::Entity_Polyhedra ||
1837            type == SMESH::Entity_Quad_Polyhedra )
1838       {
1839         int nbNodes;
1840         ok = proxy().perFaceConnectivity( id, connectivity, nbNodes );
1841         if ( ok && !connectivity.isEmpty() )
1842         {
1843           writer->write( tr( "NB_NODES" ), nbNodes );
1844           writer->write( tr( "CONNECTIVITY" ) );
1845           writer->indent();
1846           int nbFaces = connectivity.size();
1847           for ( int iF = 1; iF <= nbFaces; ++iF )
1848           {
1849             QString formatted = formatConnectivity( connectivity, -iF );
1850             writer->write(( type2str( SMDSAbs_Face, 0 ) + " %1 / %2" ).arg( iF ).arg( nbFaces ),
1851                           formatted );
1852           }
1853           writer->unindent();
1854         }
1855       }
1856       else
1857       {
1858         ok = proxy().elementConnectivity( id, connectivity );
1859         if ( ok && !connectivity.isEmpty() )
1860         {
1861           QString formatted = formatConnectivity( connectivity, SMDSAbs_Node );
1862           if ( !formatted.isEmpty() )
1863           {
1864             writer->write( tr( "NB_NODES" ), connectivity[ SMDSAbs_Node ].size() );
1865             writer->write( tr( "CONNECTIVITY" ), formatted ); //todo: TypeRole: ElemConnectivity
1866           }
1867         }
1868       }
1869       // - position
1870       ok = proxy().elementPosition( id, position );
1871       if ( ok && position.isValid() )
1872       {
1873         writer->write( tr( "POSITION" ), (stype2str( position.shapeType() ) + " #%1").arg( position.shapeId() ) );
1874       }
1875       // - gravity center
1876       ok = proxy().elementGravityCenter( id, xyz );
1877       if ( ok )
1878       {
1879         writer->write( tr( "GRAVITY_CENTER" ), xyz );
1880       }
1881       // - normal vector
1882       ok = proxy().elementNormal( id, xyz );
1883       if ( ok )
1884       {
1885         writer->write( tr( "NORMAL_VECTOR" ), xyz );
1886       }
1887       // - controls
1888       bool topCreated = false;
1889       for ( int i = SMESH::FT_AspectRatio; i < SMESH::FT_Undefined; i++ )
1890       {
1891         QString ctrlTitle = ctrl2str( i );
1892         if ( ctrlTitle.isEmpty() )
1893           continue;
1894         if ( !topCreated )
1895         {
1896           writer->write( tr( "CONTROLS" ) );
1897           writer->indent();
1898           topCreated = true;
1899         }
1900         double value;
1901         if ( proxy().elementControl( id, i, cprecision, value ) )
1902           writer->write( ctrlTitle, value );
1903       }
1904       if ( topCreated )
1905         writer->unindent();
1906       // - groups element belongs to
1907       QList<SMESH::SelectionProxy> groups = proxy().elementGroups( id );
1908       topCreated = false;
1909       foreach( SMESH::SelectionProxy group, groups )
1910       {
1911         if ( group && !group.name().isEmpty() )
1912         {
1913           if ( !topCreated )
1914           {
1915             writer->write( SMESHGUI_AddInfo::tr( "GROUPS" ) );
1916             writer->indent();
1917             topCreated = true;
1918           }
1919           writer->write( group.name().trimmed() ); // trim name
1920           if ( grp_details )
1921           {
1922             writer->indent();
1923             int type = group.type();
1924             if ( type == SMESH::SelectionProxy::GroupStd )
1925             {
1926               writer->write( SMESHGUI_AddInfo::tr( "TYPE" ), SMESHGUI_AddInfo::tr( "STANDALONE_GROUP" ) );
1927             }
1928             else if ( type == SMESH::SelectionProxy::GroupGeom )
1929             {
1930               writer->write( SMESHGUI_AddInfo::tr( "TYPE" ), SMESHGUI_AddInfo::tr( "GROUP_ON_GEOMETRY" ) );
1931               writer->write( SMESHGUI_AddInfo::tr( "GEOM_OBJECT" ), group.shapeName() );
1932             }
1933             else if ( type == SMESH::SelectionProxy::GroupFilter )
1934             {
1935               writer->write( SMESHGUI_AddInfo::tr( "TYPE" ), SMESHGUI_AddInfo::tr( "GROUP_ON_FILTER" ) );
1936             }
1937             int size = group.size();
1938             if ( size != -1 );
1939               writer->write( SMESHGUI_AddInfo::tr( "SIZE" ), size );
1940             QColor color = group.color();
1941             if ( color.isValid() )
1942               writer->write( SMESHGUI_AddInfo::tr( "COLOR" ), color.name() );
1943             writer->unindent();
1944           }
1945         }
1946       }
1947       if ( topCreated )
1948         writer->unindent();
1949       writer->unindent();
1950     }
1951   }  
1952 }
1953
1954 /*!
1955   \fn void SMESHGUI_ElemInfo::information( const QList<uint>& ids )
1956   \brief Show information on given mesh nodes / elements.
1957
1958   This function has to be redefined in sub-classes.
1959
1960   \param ids Nodes / elements IDs.
1961 */
1962
1963 /*!
1964   \brief Internal clean-up (reset panel).
1965
1966   Default implementation does nothing; the method has to be redefined
1967   in sub-classes to perform internal clean-up.
1968 */
1969 void SMESHGUI_ElemInfo::clearInternal()
1970 {
1971 }
1972
1973 /*!
1974   \brief Show previous chunk of information.
1975 */
1976 void SMESHGUI_ElemInfo::showPrevious()
1977 {
1978   myIndex = qMax( 0, myIndex-1 );
1979   updateControls();
1980   information( myIDs.mid( myIndex*blockSize(), blockSize() ) );
1981 }
1982
1983 /*!
1984   \brief Show next chunk of information.
1985 */
1986 void SMESHGUI_ElemInfo::showNext()
1987 {
1988   myIndex = qMin( myIndex+1, myIDs.count() / blockSize() );
1989   updateControls();
1990   information( myIDs.mid( myIndex*blockSize(), blockSize() ) );
1991 }
1992
1993 /*!
1994   \brief Update control widget state.
1995 */
1996 void SMESHGUI_ElemInfo::updateControls()
1997 {
1998   myExtra->updateControls( myIDs.count(), myIndex );
1999 }
2000
2001 /*!
2002   \brief Write information from panel to ouput stream.
2003   \param out Text stream output.
2004 */
2005 void SMESHGUI_ElemInfo::saveInfo( QTextStream &out )
2006 {
2007   // title
2008   QString title = tr( "ELEM_INFO" );
2009   out << ruler( title.size() ) << endl;
2010   out << title << endl;
2011   out << ruler( title.size() ) << endl;
2012   //  out << endl;
2013
2014   // info
2015   StreamWriter writer( out );
2016   writeInfo( &writer, myIDs );
2017   out << endl;
2018 }
2019
2020 ////////////////////////////////////////////////////////////////////////////////
2021 /// \class SMESHGUI_SimpleElemInfo
2022 /// \brief Show mesh element information in the simple text area.
2023 ////////////////////////////////////////////////////////////////////////////////
2024
2025 /*!
2026   \brief Constructor.
2027   \param parent Parent widget. Defaults to 0.
2028 */
2029 SMESHGUI_SimpleElemInfo::SMESHGUI_SimpleElemInfo( QWidget* parent )
2030   : SMESHGUI_ElemInfo( parent )
2031 {
2032   myInfo = new QTextBrowser( centralWidget() );
2033   QVBoxLayout* l = new QVBoxLayout( centralWidget() );
2034   l->setMargin( 0 );
2035   l->addWidget( myInfo );
2036
2037   connect( myInfo, SIGNAL( anchorClicked(QUrl)), this, SLOT( connectivityClicked( QUrl )));
2038 }
2039
2040 /*!
2041   \brief Show mesh element information.
2042   \param ids Nodes / elements IDs.
2043 */
2044 void SMESHGUI_SimpleElemInfo::information( const QList<uint>& ids )
2045 {
2046   clearInternal();
2047   TextWriter writer( myInfo );
2048   writeInfo( &writer, ids );
2049 }
2050
2051 /*!
2052   \brief Internal clean-up (reset widget)
2053 */
2054 void SMESHGUI_SimpleElemInfo::clearInternal()
2055 {
2056   myInfo->clear();
2057 }
2058
2059 void SMESHGUI_SimpleElemInfo::connectivityClicked(const QUrl & url)
2060 {
2061   int type = ( url.scheme()[0] == 'n' ) ? NodeConnectivity : ElemConnectivity;
2062   QString ids = url.path(); // excess chars will be filtered off by SMESHGUI_IdValidator
2063   emit( itemInfo( type, ids ));
2064 }
2065
2066 ////////////////////////////////////////////////////////////////////////////////
2067 /// \class SMESHGUI_TreeElemInfo::ItemDelegate
2068 /// \brief Item delegate for tree mesh info widget.
2069 /// \internal
2070 ////////////////////////////////////////////////////////////////////////////////
2071
2072 class SMESHGUI_TreeElemInfo::ItemDelegate : public QItemDelegate
2073 {
2074 public:
2075   ItemDelegate( QObject* );
2076   QWidget* createEditor( QWidget*, const QStyleOptionViewItem&, const QModelIndex& ) const;
2077 };
2078
2079 /*!
2080   \brief Constructor.
2081   \internal
2082 */
2083 SMESHGUI_TreeElemInfo::ItemDelegate::ItemDelegate( QObject* parent ): QItemDelegate( parent )
2084 {
2085 }
2086
2087 /*!
2088   \brief Redefined from QItemDelegate.
2089   \internal
2090 */
2091 QWidget* SMESHGUI_TreeElemInfo::ItemDelegate::createEditor( QWidget* parent, const QStyleOptionViewItem& option, const QModelIndex& index ) const
2092 {
2093   QWidget* w = index.column() == 0 ? 0: QItemDelegate::createEditor( parent, option, index );
2094   if ( qobject_cast<QLineEdit*>( w ) )
2095     qobject_cast<QLineEdit*>( w )->setReadOnly( true );
2096   return w;
2097 }
2098
2099 ////////////////////////////////////////////////////////////////////////////////
2100 /// \class SMESHGUI_TreeElemInfo::ItemCreator
2101 /// \brief Item creator for tree mesh info widget.
2102 /// \internal
2103 ////////////////////////////////////////////////////////////////////////////////
2104
2105 class SMESHGUI_TreeElemInfo::ItemCreator : public TreeItemCreator
2106 {
2107   SMESHGUI_TreeElemInfo* myView;
2108 public:
2109   ItemCreator( SMESHGUI_TreeElemInfo* );
2110   QTreeWidgetItem* createItem( QTreeWidgetItem*, int );
2111 };
2112
2113 /*!
2114   \brief Constructor.
2115   \param view Parent view.
2116   \internal
2117 */
2118 SMESHGUI_TreeElemInfo::ItemCreator::ItemCreator( SMESHGUI_TreeElemInfo* view ): TreeItemCreator(), myView( view )
2119 {
2120 }
2121
2122 /*!
2123   \brief Create new tree item.
2124   \param parent Parent tree item.
2125   \param options Item options.
2126   \return New tree widget item.
2127   \internal
2128 */
2129 QTreeWidgetItem* SMESHGUI_TreeElemInfo::ItemCreator::createItem( QTreeWidgetItem* parent, int options )
2130 {
2131   return myView->createItem( parent, options );
2132 }
2133
2134 ////////////////////////////////////////////////////////////////////////////////
2135 /// \class SMESHGUI_TreeElemInfo
2136 /// \brief Show mesh element information as the tree.
2137 ////////////////////////////////////////////////////////////////////////////////
2138
2139 /*!
2140   \brief Constructor.
2141   \param parent Parent widget. Defaults to 0.
2142 */
2143 SMESHGUI_TreeElemInfo::SMESHGUI_TreeElemInfo( QWidget* parent )
2144   : SMESHGUI_ElemInfo( parent )
2145 {
2146   myInfo = new QTreeWidget( centralWidget() );
2147   myInfo->setColumnCount( 2 );
2148   myInfo->setHeaderLabels( QStringList() << tr( "PROPERTY" ) << tr( "VALUE" ) );
2149   myInfo->header()->setStretchLastSection( true );
2150 #if QT_VERSION < QT_VERSION_CHECK(5, 0, 0)
2151   myInfo->header()->setResizeMode( 0, QHeaderView::ResizeToContents );
2152 #else
2153   myInfo->header()->setSectionResizeMode( 0, QHeaderView::ResizeToContents );
2154 #endif
2155   myInfo->setItemDelegate( new ItemDelegate( myInfo ) );
2156   QVBoxLayout* l = new QVBoxLayout( centralWidget() );
2157   l->setMargin( 0 );
2158   l->addWidget( myInfo );
2159   connect( myInfo, SIGNAL( itemDoubleClicked( QTreeWidgetItem*, int ) ), this, SLOT( itemDoubleClicked( QTreeWidgetItem*, int ) ) );
2160   connect( myInfo, SIGNAL( itemCollapsed( QTreeWidgetItem* )), this, SLOT( saveExpanded( QTreeWidgetItem* )) );
2161   connect( myInfo, SIGNAL( itemExpanded( QTreeWidgetItem* )), this, SLOT( saveExpanded( QTreeWidgetItem* )) );
2162 }
2163
2164 /*!
2165   \brief Show mesh element information.
2166   \param ids Nodes / elements IDs.
2167 */
2168 void SMESHGUI_TreeElemInfo::information( const QList<uint>& ids )
2169 {
2170   clearInternal();
2171   TreeWriter writer( myInfo, new ItemCreator( this ) );
2172   writeInfo( &writer, ids );
2173 }
2174
2175 /*!
2176   \brief Show node information
2177   \param node mesh node for showing
2178   \param index index of current node
2179   \param nbNodes number of unique nodes in element
2180   \param parentItem parent item of tree
2181 */
2182 void SMESHGUI_TreeElemInfo::nodeInfo( const SMDS_MeshNode* node, int index,
2183                                       int nbNodes, QTreeWidgetItem* parentItem )
2184 {
2185   // int precision   = SMESHGUI::resourceMgr()->integerValue( "SMESH", "length_precision", 6 );
2186   // // node number and ID
2187   // QTreeWidgetItem* nodeItem = createItem( parentItem, Bold );
2188   // nodeItem->setText( 0, QString( "%1 %2 / %3" ).arg( SMESHGUI_ElemInfo::tr( "NODE" )).arg( index ).arg( nbNodes ));
2189   // nodeItem->setText( 1, QString( "#%1" ).arg( node->GetID() ));
2190   // nodeItem->setData( 1, TypeRole, ElemConnectivity );
2191   // nodeItem->setData( 1, IdRole, node->GetID() );
2192   // nodeItem->setExpanded( false );
2193   // // node coordinates
2194   // QTreeWidgetItem* coordItem = createItem( nodeItem );
2195   // coordItem->setText( 0, SMESHGUI_ElemInfo::tr( "COORDINATES" ));
2196   // QTreeWidgetItem* xItem = createItem( coordItem );
2197   // xItem->setText( 0, "X" );
2198   // xItem->setText( 1, QString::number( node->X(), precision > 0 ? 'f' : 'g', qAbs( precision )) );
2199   // QTreeWidgetItem* yItem = createItem( coordItem );
2200   // yItem->setText( 0, "Y" );
2201   // yItem->setText( 1, QString::number( node->Y(), precision > 0 ? 'f' : 'g', qAbs( precision )) );
2202   // QTreeWidgetItem* zItem = createItem( coordItem );
2203   // zItem->setText( 0, "Z" );
2204   // zItem->setText( 1, QString::number( node->Z(), precision > 0 ? 'f' : 'g', qAbs( precision )) );
2205   // // node connectivity
2206   // QTreeWidgetItem* nconItem = createItem( nodeItem );
2207   // nconItem->setText( 0, SMESHGUI_ElemInfo::tr( "CONNECTIVITY" ));
2208   // Connectivity connectivity = nodeConnectivity( node );
2209   // if ( !connectivity.isEmpty() ) {
2210   //   QString con = formatConnectivity( connectivity, SMDSAbs_0DElement );
2211   //   if ( !con.isEmpty() ) {
2212   //     QTreeWidgetItem* i = createItem( nconItem );
2213   //     i->setText( 0, SMESHGUI_ElemInfo::tr( "0D_ELEMENTS" ));
2214   //     i->setText( 1, con );
2215   //   }
2216   //   con = formatConnectivity( connectivity, SMDSAbs_Edge );
2217   //   if ( !con.isEmpty() ) {
2218   //     QTreeWidgetItem* i = createItem( nconItem );
2219   //     i->setText( 0, SMESHGUI_ElemInfo::tr( "EDGES" ));
2220   //     i->setText( 1, con );
2221   //     i->setData( 1, TypeRole, NodeConnectivity );
2222   //   }
2223   //   con = formatConnectivity( connectivity, SMDSAbs_Ball );
2224   //   if ( !con.isEmpty() ) {
2225   //     QTreeWidgetItem* i = createItem( nconItem );
2226   //     i->setText( 0, SMESHGUI_ElemInfo::tr( "BALL_ELEMENTS" ));
2227   //     i->setText( 1, con );
2228   //     i->setData( 1, TypeRole, NodeConnectivity );
2229   //   }
2230   //   con = formatConnectivity( connectivity, SMDSAbs_Face );
2231   //   if ( !con.isEmpty() ) {
2232   //     QTreeWidgetItem* i = createItem( nconItem );
2233   //     i->setText( 0, SMESHGUI_ElemInfo::tr( "FACES" ));
2234   //     i->setText( 1, con );
2235   //     i->setData( 1, TypeRole, NodeConnectivity );
2236   //   }
2237   //   con = formatConnectivity( connectivity, SMDSAbs_Volume );
2238   //   if ( !con.isEmpty() ) {
2239   //     QTreeWidgetItem* i = createItem( nconItem );
2240   //     i->setText( 0, SMESHGUI_ElemInfo::tr( "VOLUMES" ));
2241   //     i->setText( 1, con );
2242   //     i->setData( 1, TypeRole, NodeConnectivity );
2243   //   }
2244   // }
2245 }
2246 /*!
2247   \brief Internal clean-up (reset widget)
2248 */
2249 void SMESHGUI_TreeElemInfo::clearInternal()
2250 {
2251   myInfo->clear();
2252   myInfo->repaint();
2253 }
2254
2255 /*!
2256   \brief Create new item and add it to the tree.
2257   \param parent Parent tree widget item. Defaults to 0 (top-level item).
2258   \param options Item flags. Defaults to 0 (none).
2259   \return New tree widget item.
2260 */
2261 QTreeWidgetItem* SMESHGUI_TreeElemInfo::createItem( QTreeWidgetItem* parent, int options )
2262 {
2263   QTreeWidgetItem* item = new QTreeWidgetItem( parent ? parent : myInfo->invisibleRootItem() );
2264   setTreeItemAttributes( item, options | Expanded | Editable );
2265
2266   if ( parent && parent->childCount() == 1 && itemDepth( parent ) == 1 )
2267   {
2268     QString resName = expandedResource( parent );
2269     parent->setExpanded( SMESHGUI::resourceMgr()->booleanValue("SMESH", resName, true ));
2270   }
2271   
2272   return item;
2273 }
2274
2275 void SMESHGUI_TreeElemInfo::contextMenuEvent( QContextMenuEvent* e )
2276 {
2277   QList< QTreeWidgetItem* > widgets = myInfo->selectedItems();
2278   if ( widgets.isEmpty() ) return;
2279   QTreeWidgetItem* aTreeItem = widgets.first();
2280   int type = aTreeItem->data( 1, TypeRole ).toInt();
2281   if (( type == ElemConnectivity || type == NodeConnectivity ) &&
2282       ( !aTreeItem->text( 1 ).isEmpty() ))
2283   {
2284     QMenu menu;
2285     QAction* a = menu.addAction( tr( "SHOW_ITEM_INFO" ));
2286     if ( menu.exec( e->globalPos() ) == a )
2287       emit( itemInfo( type, aTreeItem->text( 1 )) );
2288   }
2289 }
2290
2291 void SMESHGUI_TreeElemInfo::itemDoubleClicked( QTreeWidgetItem* theItem, int theColumn )
2292 {
2293   if ( theItem ) {
2294     int type = theItem->data( 1, TypeRole ).toInt();
2295     emit( itemInfo( type, theItem->text( 1 )) );
2296   }
2297 }
2298
2299 void SMESHGUI_TreeElemInfo::saveExpanded( QTreeWidgetItem* theItem )
2300 {
2301   if ( theItem )
2302     SMESHGUI::resourceMgr()->setValue("SMESH", expandedResource( theItem ), theItem->isExpanded() );
2303 }
2304
2305 QString SMESHGUI_TreeElemInfo::expandedResource( QTreeWidgetItem* theItem )
2306 {
2307   return QString("Expanded_") + ( what()==ShowElements ? "E_" : "N_" ) + theItem->text(0);
2308 }
2309
2310 ////////////////////////////////////////////////////////////////////////////////
2311 /// \class InfoComputor
2312 /// \brief Mesh information computor.
2313 /// \internal
2314 ///
2315 /// The class is created for different computation operations. Currently it is
2316 /// used to compute size and number of underlying nodes for given group.
2317 ////////////////////////////////////////////////////////////////////////////////
2318
2319 /*!
2320   \brief Constructor.
2321   \param parent Parent object.
2322   \param proxy Object to compute information on (group).
2323   \param item Tree widget item, referenced by this computer.
2324   \param operation Value to compute.
2325   \internal
2326 */
2327 InfoComputor::InfoComputor( QObject* parent, const SMESH::SelectionProxy& proxy, int operation )
2328   : QObject( parent ), myProxy( proxy ), myOperation( operation )
2329 {
2330 }
2331
2332 /*!
2333   \brief Compute requested information.
2334   \internal
2335 */
2336 void InfoComputor::compute()
2337 {
2338   if ( myProxy )
2339   {
2340     SUIT_OverrideCursor wc;
2341     switch ( myOperation )
2342     {
2343     case GrpSize:
2344       myProxy.size( true ); // force size computation
2345       emit computed();
2346       break;
2347     case GrpNbNodes:
2348       myProxy.nbNodes( true ); // force size computation
2349       emit computed();
2350       break;
2351     default:
2352       break;
2353     }
2354   }
2355 }
2356
2357 ////////////////////////////////////////////////////////////////////////////////
2358 /// \class SMESHGUI_AddInfo
2359 /// \brief Show additional information on selected object.
2360 ///
2361 /// Displays an additional information about selected object: mesh, sub-mesh
2362 /// or group.
2363 ///
2364 /// \todo Rewrite saveInfo() method to print all data, not currently shown only.
2365 ////////////////////////////////////////////////////////////////////////////////
2366
2367 /*!
2368   \brief Constructor.
2369   \param parent Parent widget. Defaults to 0.
2370 */
2371 SMESHGUI_AddInfo::SMESHGUI_AddInfo( QWidget* parent ): SMESHGUI_Info( parent )
2372 {
2373   QVBoxLayout* l = new QVBoxLayout( this );
2374   l->setMargin( 0 );
2375   l->setSpacing( SPACING );
2376
2377   myTree = new QTreeWidget( this );
2378
2379   myTree->setColumnCount( 2 );
2380   myTree->header()->setStretchLastSection( true );
2381 #if QT_VERSION < QT_VERSION_CHECK(5, 0, 0)
2382   myTree->header()->setResizeMode( 0, QHeaderView::ResizeToContents );
2383 #else
2384   myTree->header()->setSectionResizeMode( 0, QHeaderView::ResizeToContents );
2385 #endif
2386   myTree->header()->hide();
2387
2388   l->addWidget( myTree );
2389 }
2390
2391 /*!
2392   \brief Destructor.
2393 */
2394 SMESHGUI_AddInfo::~SMESHGUI_AddInfo()
2395 {
2396 }
2397
2398 /*!
2399   \brief Show information on given object.
2400   \param proxy Object to show information on (mesh, sub-mesh, group).
2401 */
2402 void SMESHGUI_AddInfo::showInfo( const SMESH::SelectionProxy& proxy )
2403 {
2404   // reset panel
2405   setProperty( "group_index", 0 );
2406   setProperty( "submesh_index",  0 );
2407   myComputors.clear();
2408   myTree->clear();
2409
2410   // then fill panel with data if object is not null
2411   if ( proxy )
2412   {
2413     myProxy = proxy;
2414
2415     // name
2416     QTreeWidgetItem* nameItem = createItem( 0, Bold | AllColumns );
2417     nameItem->setText( 0, tr( "NAME" ) );
2418     nameItem->setText( 1, proxy.name() );
2419
2420     // object info
2421     if ( proxy.type() == SMESH::SelectionProxy::Mesh )
2422       meshInfo( proxy, nameItem );
2423     else if ( proxy.type() == SMESH::SelectionProxy::Submesh )
2424       subMeshInfo( proxy, nameItem );
2425     else if ( proxy.type() >= SMESH::SelectionProxy::Group )
2426       groupInfo( proxy, nameItem );
2427   }
2428 }
2429
2430 /*!
2431   \brief Update information in panel.
2432 */
2433 void SMESHGUI_AddInfo::updateInfo()
2434 {
2435   showInfo( myProxy );
2436 }
2437
2438 /*!
2439   \brief Reset panel (clear all data).
2440 */
2441 void SMESHGUI_AddInfo::clear()
2442 {
2443   myTree->clear();
2444 }
2445
2446 /*!
2447   \brief Create new item and add it to the tree.
2448   \param parent Parent tree widget item. Defaults to 0 (top-level item).
2449   \param options Item flags. Defaults to 0 (none).
2450   \return New tree widget item.
2451 */
2452 QTreeWidgetItem* SMESHGUI_AddInfo::createItem( QTreeWidgetItem* parent, int options )
2453 {
2454   QTreeWidgetItem* item = parent ? new QTreeWidgetItem( parent ) : 
2455     new QTreeWidgetItem( myTree->invisibleRootItem() );
2456   setTreeItemAttributes( item, options | Expanded );
2457   return item;
2458 }
2459
2460 /*!
2461   \brief Show information on mesh.
2462   \param proxy Proxy object (mesh).
2463   \param parent Parent tree item.
2464 */
2465 void SMESHGUI_AddInfo::meshInfo( const SMESH::SelectionProxy& proxy, QTreeWidgetItem* parent )
2466 {
2467   if ( !proxy )
2468     return;
2469
2470   QString shapeName = proxy.shapeName();
2471   SMESH::MedInfo inf = proxy.medFileInfo();
2472
2473   // type
2474   QTreeWidgetItem* typeItem = createItem( parent, Bold );
2475   typeItem->setText( 0, tr( "TYPE" ) );
2476   if ( !shapeName.isEmpty() )
2477   {
2478     typeItem->setText( 1, tr( "MESH_ON_GEOMETRY" ) );
2479     // shape
2480     QTreeWidgetItem* gobjItem = createItem( parent, Bold );
2481     gobjItem->setText( 0, tr( "GEOM_OBJECT" ) );
2482     gobjItem->setText( 1, shapeName );
2483   }
2484   else if ( inf.isValid() )
2485   {
2486     typeItem->setText( 1, tr( "MESH_FROM_FILE" ) );
2487     // med file information
2488     QTreeWidgetItem* fileItem = createItem( parent, Bold );
2489     fileItem->setText( 0, tr( "FILE_NAME" ) );
2490     fileItem->setText( 1, inf.fileName() );
2491     QTreeWidgetItem* sizeItem = createItem( parent, Bold );
2492     sizeItem->setText( 0, tr( "FILE_SIZE" ) );
2493     sizeItem->setText( 1, QString::number( inf.size() ) );
2494     QTreeWidgetItem* versionItem = createItem( parent, Bold );
2495     versionItem->setText( 0, tr( "FILE_VERSION" ) );
2496     versionItem->setText( 1, inf.version() != "0" ? inf.version() : tr( "VERSION_UNKNOWN" ) );
2497   }
2498   else
2499   {
2500     typeItem->setText( 1, tr( "STANDALONE_MESH" ) );
2501   }
2502   
2503   // groups
2504   myGroups = proxy.groups();
2505   showGroups();
2506
2507   // sub-meshes
2508   mySubMeshes = proxy.submeshes();
2509   showSubMeshes();
2510 }
2511
2512 /*!
2513   \brief Show information on sub-mesh.
2514   \param proxy Proxy object (sub-mesh).
2515   \param parent Parent tree item.
2516 */
2517 void SMESHGUI_AddInfo::subMeshInfo( const SMESH::SelectionProxy& proxy, QTreeWidgetItem* parent )
2518 {
2519   if ( !proxy )
2520     return;
2521
2522   bool isShort = parent->parent() != 0;
2523
2524   if ( !isShort )
2525   {
2526     // parent mesh
2527     SMESH::SelectionProxy meshProxy = proxy.mesh();
2528     if ( meshProxy )
2529     {
2530       QTreeWidgetItem* nameItem = createItem( parent, Bold );
2531       nameItem->setText( 0, tr( "PARENT_MESH" ) );
2532       nameItem->setText( 1, meshProxy.name() );
2533     }
2534   }
2535   
2536   // shape
2537   QString shapeName = proxy.shapeName();
2538   if ( !shapeName.isEmpty() )
2539   {
2540     QTreeWidgetItem* gobjItem = createItem( parent, Bold );
2541     gobjItem->setText( 1, shapeName );
2542   }
2543 }
2544
2545 /*!
2546   \brief Show information on group.
2547   \param proxy Proxy object (group).
2548   \param parent Parent tree item.
2549 */
2550 void SMESHGUI_AddInfo::groupInfo( const SMESH::SelectionProxy& proxy, QTreeWidgetItem* parent )
2551 {
2552   if ( !proxy )
2553     return;
2554
2555   bool isShort = parent->parent() != 0;
2556
2557   if ( !isShort )
2558   {
2559     // parent mesh
2560     SMESH::SelectionProxy meshProxy = proxy.mesh();
2561     if ( meshProxy )
2562     {
2563       QTreeWidgetItem* nameItem = createItem( parent, Bold );
2564       nameItem->setText( 0, tr( "PARENT_MESH" ) );
2565       nameItem->setText( 1, meshProxy.name() );
2566     }
2567   }
2568
2569   // type
2570   SMESH::SelectionProxy::Type type = proxy.type();
2571   QTreeWidgetItem* typeItem = createItem( parent, Bold );
2572   typeItem->setText( 0, tr( "TYPE" ) );
2573   if ( type == SMESH::SelectionProxy::GroupStd )
2574   {
2575     typeItem->setText( 1, tr( "STANDALONE_GROUP" ) );
2576   }
2577   else if ( type == SMESH::SelectionProxy::GroupGeom )
2578   {
2579     typeItem->setText( 1, tr( "GROUP_ON_GEOMETRY" ) );
2580     // shape
2581     QTreeWidgetItem* gobjItem = createItem( parent, Bold );
2582     gobjItem->setText( 0, tr( "GEOM_OBJECT" ) );
2583     gobjItem->setText( 1, proxy.shapeName() );
2584   }
2585   else if ( type == SMESH::SelectionProxy::GroupFilter )
2586   {
2587     typeItem->setText( 1, tr( "GROUP_ON_FILTER" ) );
2588   }
2589
2590   // element type
2591   int etype = proxy.groupElementType();
2592   if ( !isShort )
2593   {
2594     QString typeName = tr( "UNKNOWN" );
2595     switch( etype )
2596     {
2597     case SMESH::NODE:
2598       typeName = tr( "NODE" );
2599       break;
2600     case SMESH::EDGE:
2601       typeName = tr( "EDGE" );
2602       break;
2603     case SMESH::FACE:
2604       typeName = tr( "FACE" );
2605       break;
2606     case SMESH::VOLUME:
2607       typeName = tr( "VOLUME" );
2608       break;
2609     case SMESH::ELEM0D:
2610       typeName = tr( "0DELEM" );
2611       break;
2612     case SMESH::BALL:
2613       typeName = tr( "BALL" );
2614       break;
2615     default:
2616       break;
2617     }
2618     QTreeWidgetItem* etypeItem = createItem( parent, Bold );
2619     etypeItem->setText( 0, tr( "ENTITY_TYPE" ) );
2620     etypeItem->setText( 1, typeName );
2621   }
2622
2623   // size
2624   // note: size is not computed for group on filter for performance reasons, see IPAL52831
2625   bool meshLoaded = proxy.isMeshLoaded();
2626   int size = proxy.size();
2627
2628   QTreeWidgetItem* sizeItem = createItem( parent, Bold );
2629   sizeItem->setText( 0, tr( "SIZE" ) );
2630   if ( size >= 0 )
2631   {
2632     sizeItem->setText( 1, QString::number( size ) );
2633   }
2634   else
2635   {
2636     QPushButton* btn = new QPushButton( meshLoaded ? tr( "COMPUTE" ) : tr( "LOAD" ), this );
2637     myTree->setItemWidget( sizeItem, 1, btn );
2638     InfoComputor* comp = new InfoComputor( this, proxy, InfoComputor::GrpSize );
2639     connect( btn, SIGNAL( clicked() ), comp, SLOT( compute() ) );
2640     connect( comp, SIGNAL( computed() ), this, SLOT( updateInfo() ) );
2641     myComputors.append( comp );
2642   }
2643
2644   // color
2645   QTreeWidgetItem* colorItem = createItem( parent, Bold );
2646   colorItem->setText( 0, tr( "COLOR" ) );
2647   colorItem->setBackground( 1, proxy.color() );
2648
2649   // nb of underlying nodes
2650   if ( etype != SMESH::NODE )
2651   {
2652     QTreeWidgetItem* nodesItem = createItem( parent, Bold );
2653     nodesItem->setText( 0, tr( "NB_NODES" ) );
2654
2655     int nbNodes = proxy.nbNodes();
2656     if ( nbNodes >= 0 )
2657     {
2658       nodesItem->setText( 1, QString::number( nbNodes ) );
2659     }
2660     else
2661     {
2662       QPushButton* btn = new QPushButton( meshLoaded ? tr( "COMPUTE" ) : tr( "LOAD" ), this );
2663       myTree->setItemWidget( nodesItem, 1, btn );
2664       InfoComputor* comp = new InfoComputor( this, proxy, InfoComputor::GrpNbNodes ); 
2665       connect( btn, SIGNAL( clicked() ), comp, SLOT( compute() ) );
2666       connect( comp, SIGNAL( computed() ), this, SLOT( updateInfo() ) );
2667       myComputors.append( comp );
2668     }
2669   }
2670 }
2671
2672 /*!
2673   \brief Update information on child groups.
2674 */
2675 void SMESHGUI_AddInfo::showGroups()
2676 {
2677   // remove all computors
2678   myComputors.clear();
2679
2680   // tree root should be the first top level item
2681   QTreeWidgetItem* parent = myTree->topLevelItemCount() > 0 ? myTree->topLevelItem( 0 ) : 0;
2682   if ( !parent )
2683     return;
2684
2685   int idx = property( "group_index" ).toInt();
2686
2687   // find sub-meshes top-level container item
2688   QTreeWidgetItem* itemGroups = 0;
2689   for ( int i = 0; i < parent->childCount() && !itemGroups; i++ )
2690   {
2691     if ( parent->child( i )->data( 0, Qt::UserRole ).toInt() == GroupsId )
2692     {
2693       itemGroups = parent->child( i );
2694       // update controls
2695       ExtraWidget* extra = dynamic_cast<ExtraWidget*>( myTree->itemWidget( itemGroups, 1 ) );
2696       if ( extra )
2697         extra->updateControls( myGroups.count(), idx );
2698       // clear: remove all group items
2699       while ( itemGroups->childCount() )
2700         delete itemGroups->child( 0 );
2701     }
2702   }
2703
2704   QMap<int, QTreeWidgetItem*> grpItems;
2705   for ( int i = idx*blockSize() ; i < qMin( (idx+1)*blockSize(), (int)myGroups.count() ); i++ )
2706   {
2707     SMESH::SelectionProxy grp = myGroups[i];
2708     if ( !grp )
2709       continue;
2710
2711     int grpType = grp.groupElementType();
2712
2713     // create top-level groups container item if it does not exist
2714     if ( !itemGroups )
2715     {
2716       itemGroups = createItem( parent, Bold | AllColumns );
2717       itemGroups->setText( 0, tr( "GROUPS" ) );
2718       itemGroups->setData( 0, Qt::UserRole, GroupsId );
2719
2720       // if necessary, create extra widget to show information by chunks
2721       if ( myGroups.count() > blockSize() )
2722       {
2723         ExtraWidget* extra = new ExtraWidget( this, true );
2724         connect( extra->prev, SIGNAL( clicked() ), this, SLOT( showPreviousGroups() ) );
2725         connect( extra->next, SIGNAL( clicked() ), this, SLOT( showNextGroups() ) );
2726         myTree->setItemWidget( itemGroups, 1, extra );
2727         extra->updateControls( myGroups.count(), idx );
2728       }
2729     }
2730
2731     // create container item corresponding to particular element type
2732     if ( !grpItems.contains( grpType ) )
2733     {
2734       grpItems[ grpType ] = createItem( itemGroups, Bold | AllColumns );
2735       grpItems[ grpType ]->setText( 0, tr( QString( "GROUPS_%1" ).arg( grpType ).toLatin1().constData() ) );
2736       itemGroups->insertChild( grpType-1, grpItems[ grpType ] ); // -1 needed since 0 corresponds to SMESH::ALL
2737     }
2738   
2739     // name
2740     QTreeWidgetItem* nameItem = createItem( grpItems[ grpType ] );
2741     nameItem->setText( 0, grp.name().trimmed() ); // trim name
2742
2743     // group info
2744     groupInfo( grp, nameItem );
2745   }
2746 }
2747
2748 /*!
2749   \brief Update information on child sub-meshes.
2750 */
2751 void SMESHGUI_AddInfo::showSubMeshes()
2752 {
2753   // tree root should be the first top level item
2754   QTreeWidgetItem* parent = myTree->topLevelItemCount() > 0 ? myTree->topLevelItem( 0 ) : 0;
2755   if ( !parent )
2756     return;
2757
2758   int idx = property( "submesh_index" ).toInt();
2759
2760   // find sub-meshes top-level container item
2761   QTreeWidgetItem* itemSubMeshes = 0;
2762   for ( int i = 0; i < parent->childCount() && !itemSubMeshes; i++ )
2763   {
2764     if ( parent->child( i )->data( 0, Qt::UserRole ).toInt() == SubMeshesId )
2765     {
2766       itemSubMeshes = parent->child( i );
2767       // update controls
2768       ExtraWidget* extra = dynamic_cast<ExtraWidget*>( myTree->itemWidget( itemSubMeshes, 1 ) );
2769       if ( extra )
2770         extra->updateControls( mySubMeshes.count(), idx );
2771       // clear: remove all sub-mesh items
2772       while ( itemSubMeshes->childCount() )
2773         delete itemSubMeshes->child( 0 );
2774     }
2775   }
2776
2777   QMap<int, QTreeWidgetItem*> smItems;
2778   for ( int i = idx*blockSize() ; i < qMin( (idx+1)*blockSize(), mySubMeshes.count() ); i++ )
2779   {
2780     SMESH::SelectionProxy sm = mySubMeshes[i];
2781     if ( !sm )
2782       continue;
2783     
2784     int smType = sm.shapeType();
2785     if ( smType < 0 )
2786       continue;
2787     else if ( smType == GEOM::COMPSOLID )
2788       smType = GEOM::COMPOUND;
2789
2790     // create top-level sub-meshes container item if it does not exist
2791     if ( !itemSubMeshes )
2792     {
2793       itemSubMeshes = createItem( parent, Bold | AllColumns );
2794       itemSubMeshes->setText( 0, tr( "SUBMESHES" ) );
2795       itemSubMeshes->setData( 0, Qt::UserRole, SubMeshesId );
2796
2797       // if necessary, create extra widget to show information by chunks
2798       if ( mySubMeshes.count() > blockSize() )
2799       {
2800         ExtraWidget* extra = new ExtraWidget( this, true );
2801         connect( extra->prev, SIGNAL( clicked() ), this, SLOT( showPreviousSubMeshes() ) );
2802         connect( extra->next, SIGNAL( clicked() ), this, SLOT( showNextSubMeshes() ) );
2803         myTree->setItemWidget( itemSubMeshes, 1, extra );
2804         extra->updateControls( mySubMeshes.count(), idx );
2805       }
2806     }
2807
2808     // create container item corresponding to particular shape type
2809     if ( !smItems.contains( smType ) )
2810     {
2811       smItems[ smType ] = createItem( itemSubMeshes, Bold | AllColumns );
2812       smItems[ smType ]->setText( 0, tr( QString( "SUBMESHES_%1" ).arg( smType ).toLatin1().constData() ) );
2813       itemSubMeshes->insertChild( smType, smItems[ smType ] );
2814     }
2815     
2816     // name
2817     QTreeWidgetItem* nameItem = createItem( smItems[ smType ] );
2818     nameItem->setText( 0, sm.name().trimmed() ); // trim name
2819     
2820     // submesh info
2821     subMeshInfo( sm, nameItem );
2822   }
2823 }
2824
2825 /*!
2826   \brief Show previous chunk of information on child groups.
2827 */
2828 void SMESHGUI_AddInfo::showPreviousGroups()
2829 {
2830   int idx = property( "group_index" ).toInt();
2831   setProperty( "group_index", idx-1 );
2832   showGroups();
2833 }
2834
2835 /*!
2836   \brief Show next chunk of information on child groups.
2837 */
2838 void SMESHGUI_AddInfo::showNextGroups()
2839 {
2840   int idx = property( "group_index" ).toInt();
2841   setProperty( "group_index", idx+1 );
2842   showGroups();
2843 }
2844
2845 /*!
2846   \brief Show previous chunk of information on child sub-meshes.
2847 */
2848 void SMESHGUI_AddInfo::showPreviousSubMeshes()
2849 {
2850   int idx = property( "submesh_index" ).toInt();
2851   setProperty( "submesh_index", idx-1 );
2852   showSubMeshes();
2853 }
2854
2855 /*!
2856   \brief Show next chunk of information on child sub-meshes.
2857 */
2858 void SMESHGUI_AddInfo::showNextSubMeshes()
2859 {
2860   int idx = property( "submesh_index" ).toInt();
2861   setProperty( "submesh_index", idx+1 );
2862   showSubMeshes();
2863 }
2864
2865 /*!
2866   \brief Write information from panel to ouput stream.
2867   \param out Text stream output.
2868 */
2869 void SMESHGUI_AddInfo::saveInfo( QTextStream &out )
2870 {
2871   // title
2872   QString title = tr( "ADDITIONAL_INFO" );
2873   out << ruler( title.size() ) << endl;
2874   out << title << endl;
2875   out << ruler( title.size() ) << endl;
2876   out << endl;
2877
2878   // info
2879   QTreeWidgetItemIterator it( myTree );
2880   while ( *it )
2881   {
2882     if ( !( ( *it )->text(0) ).isEmpty() )
2883     {
2884       out << indent( itemDepth( *it ) ) << ( *it )->text(0);
2885       if ( ( *it )->text(0)  == tr( "COLOR" ) )
2886         out << ":" << spacing() << ( ( ( *it )->background(1) ).color() ).name();
2887       else if ( !( ( *it )->text(1) ).isEmpty() )
2888         out << ":" << spacing() << ( *it )->text(1);
2889       out << endl;
2890     }
2891     ++it;
2892   }
2893   out << endl;
2894 }
2895
2896 ////////////////////////////////////////////////////////////////////////////////
2897 /// \class GroupCombo
2898 /// \brief Customized combo box to manage list of mesh groups.
2899 /// \internal
2900 ////////////////////////////////////////////////////////////////////////////////
2901
2902 class GroupCombo: public QComboBox
2903 {
2904   class Item: public QStandardItem
2905   {
2906   public:
2907     SMESH::SelectionProxy myGroup;
2908     Item( const SMESH::SelectionProxy& group )
2909     {
2910       myGroup = group;
2911       setText( myGroup.name() );
2912     }
2913     SMESH::SelectionProxy group()
2914     {
2915       return myGroup;
2916     }
2917   };
2918
2919   SMESH::SelectionProxy myProxy;
2920
2921 public:
2922   GroupCombo( QWidget* );
2923   void setSource( const SMESH::SelectionProxy& );
2924   SMESH::SelectionProxy currentGroup() const;
2925 };
2926
2927 /*!
2928   \brief Contructor.
2929   \param parent Parent widget.
2930   \internal
2931 */
2932 GroupCombo::GroupCombo( QWidget* parent ): QComboBox( parent )
2933 {
2934   setModel( new QStandardItemModel( this ) );
2935 }
2936
2937 /*!
2938   \brief Set mesh source.
2939   \param obj Mesh source.
2940   \internal
2941 */
2942 void GroupCombo::setSource( const SMESH::SelectionProxy& proxy )
2943 {
2944   if ( myProxy == proxy )
2945     return;
2946
2947   myProxy = proxy;
2948
2949   bool blocked = blockSignals( true );
2950   QStandardItemModel* m = dynamic_cast<QStandardItemModel*>( model() );
2951   m->clear();
2952
2953   if ( myProxy )
2954   {
2955     if ( myProxy.type() == SMESH::SelectionProxy::Mesh )
2956     {
2957       QList<SMESH::SelectionProxy> groups = myProxy.groups();
2958       for ( int i = 0; i < groups.count(); ++i )
2959       {
2960         if ( groups[i] )
2961         {
2962           QString name = groups[i].name();
2963           if ( !name.isEmpty() )
2964             m->appendRow( new Item( groups[i] ) );
2965         }
2966       }
2967       setCurrentIndex( -1 ); // for performance reasons
2968     }
2969     else if ( myProxy.type() >= SMESH::SelectionProxy::Group )
2970     {
2971       m->appendRow( new Item( myProxy ) );
2972       setCurrentIndex( 0 );
2973     }
2974   }
2975
2976   blockSignals( blocked );
2977 }
2978
2979 /*!
2980   \brief Get currently selected group.
2981   \return Selected group.
2982   \internal
2983 */
2984 SMESH::SelectionProxy GroupCombo::currentGroup() const
2985 {
2986   SMESH::SelectionProxy group;
2987   QStandardItemModel* m = dynamic_cast<QStandardItemModel*>( model() );
2988   if ( currentIndex() >= 0 )
2989     group = dynamic_cast<Item*>( m->item( currentIndex() ) )->group();
2990   return group;
2991 }
2992
2993 ////////////////////////////////////////////////////////////////////////////////
2994 /// \class SMESHGUI_MeshInfoDlg
2995 /// \brief Mesh information dialog box
2996 ///
2997 /// \todo Move all business logic for element info to SMESHGUI_ElemInfo class.
2998 /// \todo Add selection button to reactivate selection on move from other dlg.
2999 ////////////////////////////////////////////////////////////////////////////////
3000
3001 /*!
3002   \brief Constructor
3003   \param parent Parent widget.
3004   \param page Dialog page to show at start-up. Defaults to \c BaseInfo.
3005 */
3006 SMESHGUI_MeshInfoDlg::SMESHGUI_MeshInfoDlg( QWidget* parent, int page )
3007   : QDialog( parent )
3008 {
3009   setModal( false );
3010   setAttribute( Qt::WA_DeleteOnClose, true );
3011   setWindowTitle( tr( "MESH_INFO" ) );
3012   setSizeGripEnabled( true );
3013
3014   myTabWidget = new QTabWidget( this );
3015
3016   // base info
3017
3018   myBaseInfo = new SMESHGUI_BaseInfo( myTabWidget );
3019   myTabWidget->addTab( myBaseInfo, tr( "BASE_INFO" ) );
3020
3021   // elem info 
3022
3023   QWidget* w = new QWidget( myTabWidget );
3024
3025   myMode = new QButtonGroup( this );
3026   myMode->addButton( new QRadioButton( tr( "NODE_MODE" ), w ), NodeMode );
3027   myMode->addButton( new QRadioButton( tr( "ELEM_MODE" ), w ), ElemMode );
3028   myMode->addButton( new QRadioButton( tr( "GROUP_MODE" ), w ), GroupMode );
3029   myMode->button( NodeMode )->setChecked( true );
3030   myID = new QLineEdit( w );
3031   myID->setValidator( new SMESHGUI_IdValidator( this ) );
3032   myGroups = new GroupCombo( w );
3033   QStackedWidget* stack = new QStackedWidget( w );
3034   stack->addWidget( myID );
3035   stack->addWidget( myGroups );
3036   myIDPreviewCheck = new QCheckBox( tr( "SHOW_IDS" ), w );
3037   myIDPreview = new SMESHGUI_IdPreview( SMESH::GetViewWindow( SMESHGUI::GetSMESHGUI() ) );
3038
3039   int mode = SMESHGUI::resourceMgr()->integerValue( "SMESH", "mesh_elem_info", 1 );
3040   mode = qMin( 1, qMax( 0, mode ) );
3041
3042   if ( mode == 0 )
3043     myElemInfo = new SMESHGUI_SimpleElemInfo( w );
3044   else
3045     myElemInfo = new SMESHGUI_TreeElemInfo( w );
3046   stack->setSizePolicy( QSizePolicy::Expanding, QSizePolicy::Fixed );
3047
3048   QGridLayout* elemLayout = new QGridLayout( w );
3049   elemLayout->setMargin( MARGIN );
3050   elemLayout->setSpacing( SPACING );
3051   elemLayout->addWidget( myMode->button( NodeMode ), 0, 0 );
3052   elemLayout->addWidget( myMode->button( ElemMode ), 0, 1 );
3053   elemLayout->addWidget( myMode->button( GroupMode ), 0, 2 );
3054   elemLayout->addWidget( stack, 0, 3 );
3055   elemLayout->addWidget( myIDPreviewCheck, 1, 0, 1, 4 );
3056   elemLayout->addWidget( myElemInfo, 2, 0, 1, 4 );
3057
3058   myTabWidget->addTab( w, tr( "ELEM_INFO" ) );
3059
3060   // additional info
3061
3062   myAddInfo = new SMESHGUI_AddInfo( myTabWidget );
3063   myTabWidget->addTab( myAddInfo, tr( "ADDITIONAL_INFO" ) );
3064
3065   // controls info
3066
3067   myCtrlInfo = new SMESHGUI_CtrlInfo( myTabWidget );
3068   myTabWidget->addTab( myCtrlInfo, tr( "CTRL_INFO" ) );
3069
3070   // buttons
3071
3072   QPushButton* okBtn = new QPushButton( tr( "SMESH_BUT_OK" ), this );
3073   okBtn->setAutoDefault( true );
3074   okBtn->setDefault( true );
3075   okBtn->setFocus();
3076   QPushButton* dumpBtn = new QPushButton( tr( "BUT_DUMP_MESH" ), this );
3077   dumpBtn->setAutoDefault( true );
3078   QPushButton* helpBtn = new QPushButton( tr( "SMESH_BUT_HELP" ), this );
3079   helpBtn->setAutoDefault( true );
3080
3081   QHBoxLayout* btnLayout = new QHBoxLayout;
3082   btnLayout->setSpacing( SPACING );
3083   btnLayout->setMargin( 0 );
3084
3085   btnLayout->addWidget( okBtn );
3086   btnLayout->addWidget( dumpBtn );
3087   btnLayout->addStretch( 10 );
3088   btnLayout->addWidget( helpBtn );
3089
3090   // arrange widgets
3091
3092   QVBoxLayout* l = new QVBoxLayout ( this );
3093   l->setMargin( MARGIN );
3094   l->setSpacing( SPACING );
3095   l->addWidget( myTabWidget );
3096   l->addLayout( btnLayout );
3097
3098   // set initial page
3099
3100   myTabWidget->setCurrentIndex( qMax( (int)BaseInfo, qMin( (int)ElemInfo, page ) ) );
3101
3102   // set-up connections
3103
3104   connect( okBtn, SIGNAL( clicked() ), this, SLOT( reject() ) );
3105   connect( dumpBtn, SIGNAL( clicked() ), this, SLOT( dump() ) );
3106   connect( helpBtn, SIGNAL( clicked() ), this, SLOT( help() ) );
3107   connect( myTabWidget, SIGNAL( currentChanged( int ) ), this, SLOT( updateSelection() ) );
3108   connect( myMode, SIGNAL( buttonClicked( int ) ), this, SLOT( modeChanged() ) );
3109   connect( myGroups, SIGNAL( currentIndexChanged( int ) ), this, SLOT( modeChanged() ) );
3110   connect( myID, SIGNAL( textChanged( QString ) ), this, SLOT( idChanged() ) );
3111   connect( myIDPreviewCheck, SIGNAL( toggled( bool ) ), this, SLOT( idPreviewChange( bool ) ) );
3112   connect( SMESHGUI::GetSMESHGUI(), SIGNAL( SignalDeactivateActiveDialog() ), this, SLOT( deactivate() ) );
3113   connect( SMESHGUI::GetSMESHGUI(), SIGNAL( SignalCloseAllDialogs() ), this, SLOT( reject() ) );
3114   connect( myElemInfo, SIGNAL( itemInfo( int, QString ) ), this, SLOT( showItemInfo( int, QString ) ) );
3115   connect( this, SIGNAL( switchMode( int ) ), stack, SLOT( setCurrentIndex( int ) ) );
3116
3117   // initialize
3118
3119   myIDPreviewCheck->setChecked( SMESHGUI::resourceMgr()->booleanValue( "SMESH", "id_preview_resource", false ) );
3120   updateSelection();
3121 }
3122
3123 /*!
3124   \brief Destructor.
3125 */
3126 SMESHGUI_MeshInfoDlg::~SMESHGUI_MeshInfoDlg()
3127 {
3128   delete myIDPreview;
3129 }
3130
3131 /*!
3132   \brief Show mesh information on given object.
3133   \param io Interactive object.
3134 */
3135 void SMESHGUI_MeshInfoDlg::showInfo( const Handle(SALOME_InteractiveObject)& io )
3136 {
3137   if ( !io.IsNull() )
3138     showInfo( SMESH::SelectionProxy( io ) );
3139 }
3140
3141 /*!
3142   \brief Show mesh information on given object.
3143   \param proxy Selection proxy.
3144 */
3145 void SMESHGUI_MeshInfoDlg::showInfo( const SMESH::SelectionProxy& proxy )
3146 {
3147   SUIT_OverrideCursor wc;
3148
3149   if ( !proxy )
3150     return;
3151
3152   myProxy = proxy;
3153
3154   SMESH::SMESH_IDSource_var obj = myProxy.object();
3155
3156   // "Base info" tab
3157   myBaseInfo->showInfo( proxy );
3158
3159   // "Additional info" tab
3160   myAddInfo->showInfo( proxy );
3161
3162   // "Quality info" tab
3163   // Note: for performance reasons we update it only if it is currently active
3164   if ( myTabWidget->currentIndex() == CtrlInfo )
3165     myCtrlInfo->showInfo( proxy );
3166
3167   // "Element info" tab
3168   myGroups->setSource( proxy );
3169   if ( myMode->checkedId() == GroupMode ) {
3170     SMESH::SelectionProxy group = myGroups->currentGroup();
3171     if ( group )
3172       myElemInfo->showInfo( group );
3173     else
3174       myElemInfo->clear();
3175   }
3176   else {
3177     SVTK_Selector* selector = SMESH::GetSelector();
3178     QString ID;
3179     int nb = 0;
3180     if ( myProxy.actor() && selector ) { //todo: actor()?
3181       nb = myMode->checkedId() == NodeMode ?
3182         SMESH::GetNameOfSelectedElements( selector, myProxy.io(), ID ) :
3183         SMESH::GetNameOfSelectedNodes( selector, myProxy.io(), ID );
3184     }
3185     if ( nb > 0 ) {
3186       myID->setText( ID.trimmed() );
3187       QSet<uint> ids;