Code_TYMPAN  4.4.0
Industrial site acoustic simulation
TYModelerFrame.cpp
Go to the documentation of this file.
1 /*
2  * Copyright (C) <2012-2024> <EDF-DTG> <FRANCE>
3  * This file is part of Code_TYMPAN (R).
4  * Code_TYMPAN (R) is free software: you can redistribute it and/or modify
5  * it under the terms of the GNU General Public License as published by
6  * the Free Software Foundation, either version 3 of the License, or
7  * (at your option) any later version.
8  * Code_TYMPAN (R) is distributed in the hope that it will be useful,
9  * but WITHOUT ANY WARRANTY; without even the implied warranty of
10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
11  * See the GNU General Public License for more details.
12  * You should have received a copy of the GNU General Public License along
13  * with Code_TYMPAN (R). If not, see <https://www.gnu.org/licenses/>.
14  */
15 
21 #include "gui/app/TYOpenGLRenderer.h"
22 #include "models/common/3d.h"
23 #include <qvector3d.h>
24 #ifdef _MSC_VER
25  #pragma warning(disable : 4503)
26 #endif
27 
28 #include <math.h>
29 #include <qlayout.h>
30 #include <qstring.h>
31 #include <qcursor.h>
32 #include <qcombobox.h>
33 #include <qcheckbox.h>
34 #include <qlineedit.h>
35 #include <qstatusbar.h>
36 #include <qimage.h>
37 #include <qpixmap.h>
38 #include <qmenu.h>
39 #include <qfiledialog.h>
40 #include <qslider.h>
41 #include <qlabel.h>
42 #include <qprinter.h>
43 #include <qpainter.h>
44 #include <qgroupbox.h>
45 #include <qclipboard.h>
46 #include <qmessagebox.h>
47 #include <qtoolbutton.h>
48 // Added by qt3to4:
49 #include <QResizeEvent>
50 #include <QWheelEvent>
51 #include <QFocusEvent>
52 #include <QMouseEvent>
53 #include <QCloseEvent>
54 #include <QGridLayout>
55 #include <QShowEvent>
56 #include <QKeyEvent>
57 #include <QHBoxLayout>
58 #include <QEvent>
59 #include <QImageWriter>
60 #include <QPrintDialog>
61 
62 #include "Tympan/models/business/OLocalizator.h"
63 #include "Tympan/models/business/TYProjet.h"
64 #include "Tympan/models/business/TYCalcul.h"
65 #include "Tympan/models/business/TYPreferenceManager.h"
66 #include "Tympan/models/business/infrastructure/TYBatiment.h"
67 #include "Tympan/models/business/infrastructure/TYMachine.h"
68 #include "Tympan/models/business/geometry/TYGeometryNode.h"
69 #include "Tympan/gui/tools/OGLTextElement.h"
70 #include "Tympan/gui/tools/OGLScalarBarElement.h"
71 #include "Tympan/gui/tools/OGLLineElement.h"
72 #include "Tympan/gui/tools/OGLLightElement.h"
73 #include "Tympan/gui/tools/OGLGridElement.h"
74 #include "Tympan/gui/tools/OGLCamera.h"
75 #include "Tympan/gui/gl/TYSourceLineicGraphic.h"
76 #include "Tympan/gui/gl/TYSourceSurfacicGraphic.h"
77 #include "Tympan/gui/gl/TYRayGraphic.h"
78 #include "Tympan/gui/widgets/TYPrintDialog.h"
79 #include "Tympan/gui/widgets/TYInputDialog.h"
80 #include "Tympan/gui/app/TYElementPicker.h"
81 #include "Tympan/gui/app/TYCameraEditor.h"
82 #include "Tympan/gui/app/TYCameraZoneEditor.h"
83 #include "Tympan/gui/app/TYDistanceEditor.h"
84 #include "Tympan/gui/app/TYPositionEditor.h"
85 #include "Tympan/gui/app/TYPickEditor.h"
86 #include "Tympan/gui/app/TYAbstractSceneEditor.h"
87 #include "Tympan/gui/app/TYApplication.h"
88 #include "Tympan/gui/app/TYSetCameraCoordinates.h"
89 #include "TYModelerFrame.h"
90 
91 #define TR(id) OLocalizator::getString("TYModelerFrame", (id))
92 #define IMG(id) OLocalizator::getPicture("TYModelerFrame", (id))
93 
94 // using namespace Qt;
95 
96 // Couleurs
97 static double gridColor[] = {0.59, 0.41, 0.42};
98 static double fontColor[] = {0.1, 0.43, 0.37};
99 static double rendererColor[] = {0.91, 0.91, 0.91};
100 
101 TYModelerFrame::TYModelerFrame(QWidget* parent, const char* name, Qt::WindowFlags f)
102  : QWidget(parent, f), _actionManager(10)
103 {
104  setObjectName(name);
105 
106  setAttribute(Qt::WA_DeleteOnClose);
107 
108  // L'element associe a ce modeler
109  _pElement = NULL;
110 
111  // Flag pour la sauvegarde des settings
112  _firstTimeShown = true;
113 
114  // Init des membres pour les editors
115  _pCurrentEditor = NULL;
116  _lastEditorMode = NoMode;
117  _editorModeAccepted = false;
118 
119  // Init des membres pour la grille
120  _showGrid = false;
121 
122  _curViewType = PerspView;
123 
124  _defaultZCoord = 0.0f;
125 
126  // Le focus se fait avec la touche tab ou la souris
127  setFocusPolicy(Qt::StrongFocus);
128 
129  // Pour pouvoir afficher la position courante du curseur
130  setMouseTracking(true);
131 
132  // Layout
133  _pLayout = new QGridLayout();
134  _pLayout->setRowStretch(0, 0);
135  _pLayout->setRowStretch(1, 1);
136  _pLayout->setRowStretch(2, 0);
137  setLayout(_pLayout);
138 
139  // Initialisation des parametres de la grille.
140  _gridDimX = 200;
141  _gridDimY = 200;
142  _gridStep = 5;
143  _gridMagnStep = 1;
144 
145  // Widgets
146  _pCtrlLayout = new QHBoxLayout();
147  _pLayout->addLayout(_pCtrlLayout, 0, 0);
148  _pCtrlLayout->setSpacing(5);
149 
150  // Disambiguate the overloaded signal QComboBox::activated
151  void (QComboBox::*_qComboBox_activated)(int) = &QComboBox::activated;
152 
153  // Combo box type de Vue
154  _pViewTypeBox = new QComboBox(this);
155  _pCtrlLayout->addWidget(_pViewTypeBox, 0);
156  _pViewTypeBox->insertItem(TopView, TR("id_top_view"));
157  _pViewTypeBox->insertItem(BottomView, TR("id_bottom_view"));
158  _pViewTypeBox->insertItem(LeftView, TR("id_left_view"));
159  _pViewTypeBox->insertItem(RightView, TR("id_right_view"));
160  _pViewTypeBox->insertItem(FrontView, TR("id_front_view"));
161  _pViewTypeBox->insertItem(RearView, TR("id_rear_view"));
162  _pViewTypeBox->insertItem(PerspView, TR("id_3d_view"));
163  _pViewTypeBox->insertItem(FreeView, TR("id_free_view"));
164  connect(_pViewTypeBox, _qComboBox_activated, this, &TYModelerFrame::setViewType);
165 
166  // Combo box mode de Rendu
167  _pRenderModeBox = new QComboBox(this);
168  _pCtrlLayout->addWidget(_pRenderModeBox, 0);
169  _pRenderModeBox->insertItem(TYOpenGLRenderer::Points, TR("id_points_mode"));
170  _pRenderModeBox->insertItem(TYOpenGLRenderer::Wireframe, TR("id_wireframe_mode"));
171  _pRenderModeBox->insertItem(TYOpenGLRenderer::Surface, TR("id_surface_mode"));
172  connect(_pRenderModeBox, _qComboBox_activated, this, &TYModelerFrame::setRenderModeSlot);
173 
174  _pCtrlLayout->addSpacing(7);
175 
176  // Btn Fit
177  QToolButton* pFitBtn = new QToolButton(this);
178  pFitBtn->setIcon(QPixmap(IMG("id_icon_fit_btn")));
179  pFitBtn->setText(TR("id_fit_btn"));
180  pFitBtn->setToolTip(TR("id_fit_btn"));
181  pFitBtn->setFixedSize(24, 24);
182  connect(pFitBtn, &QToolButton::clicked, this, &TYModelerFrame::fit);
183  _pCtrlLayout->addWidget(pFitBtn, 0);
184 
185  // Btn Grille
186  _pGridBtn = new QToolButton(this);
187  _pGridBtn->setIcon(QPixmap(IMG("id_icon_grid_btn")));
188  _pGridBtn->setText(TR("id_grid_btn"));
189  _pGridBtn->setToolTip(TR("id_grid_btn"));
190  _pGridBtn->setCheckable(true);
191  _pGridBtn->setChecked(true);
192  _pGridBtn->setFixedSize(24, 24);
193  _pCtrlLayout->addWidget(_pGridBtn, 0);
194  connect(_pGridBtn, &QToolButton::toggled, this, &TYModelerFrame::showGrid);
195 
196  // Btn Show echelle.
197  // L'echelle est mise a jour a la fin de chaque deplacement de camera (cf. TYCameraEditor)
198  _showScale = true;
199  _pShowScale = new QToolButton(this);
200  _pShowScale->setIcon(QPixmap(IMG("id_icon_show_scale_btn")));
201  _pShowScale->setText(TR("id_show_scale_btn"));
202  _pShowScale->setToolTip(TR("id_show_scale_btn"));
203  _pShowScale->setCheckable(true);
204  _pShowScale->setChecked(_showScale);
205  _pShowScale->setFixedSize(24, 24);
206  _pCtrlLayout->addWidget(_pShowScale, 0);
207  connect(_pShowScale, &QToolButton::toggled, this, &TYModelerFrame::showScale);
208 
209  // Btn Grille Magnetique
210  _pSnapGridBtn = new QToolButton(this);
211  _pSnapGridBtn->setIcon(QPixmap(IMG("id_icon_snapgrid_btn")));
212  _pSnapGridBtn->setText(TR("id_snapgrid_btn"));
213  _pSnapGridBtn->setToolTip(TR("id_snapgrid_btn"));
214  _pSnapGridBtn->setCheckable(true);
215  _pSnapGridBtn->setFixedSize(24, 24);
216  _pCtrlLayout->addWidget(_pSnapGridBtn, 0);
217  connect(_pSnapGridBtn, &QToolButton::toggled, this, &TYModelerFrame::setSnapGridActive);
218  setSnapGridActive(true);
219 
220  // Btn set camera coordinates
221  _pSetCameraCoordinatesBtn = new QToolButton(this);
222  _pSetCameraCoordinatesBtn->setIcon(QPixmap(IMG("id_icon_setcameracoordinates_btn")));
223  _pSetCameraCoordinatesBtn->setText(TR("id_setcameracoordinates_btn"));
224  _pSetCameraCoordinatesBtn->setToolTip(TR("id_setcameracoordinates_btn"));
225  _pSetCameraCoordinatesBtn->setFixedSize(24, 24);
226  _pCtrlLayout->addWidget(_pSetCameraCoordinatesBtn, 0);
227  connect(_pSetCameraCoordinatesBtn, &QToolButton::clicked, this, &TYModelerFrame::setCameraCoordinates);
228 
229  _pCtrlLayout->addSpacing(7);
230 
231  // Btn Screenshot
232  _pScreenShotBtn = new QToolButton(this);
233  _pScreenShotBtn->setIcon(QPixmap(IMG("id_icon_screenshot_btn")));
234  _pScreenShotBtn->setText(TR("id_screenshot_btn"));
235  _pScreenShotBtn->setToolTip(TR("id_screenshot_btn"));
236  _pScreenShotBtn->setFixedSize(24, 24);
237  connect(_pScreenShotBtn, &QToolButton::clicked, this, &TYModelerFrame::screenShot);
238 
239  // Btn Copy
240  _pCopyBtn = new QToolButton(this);
241  _pCopyBtn->setIcon(QPixmap(IMG("id_icon_copy_btn")));
242  _pCopyBtn->setText(TR("id_copy_btn"));
243  _pCopyBtn->setToolTip(TR("id_copy_btn"));
244  _pCopyBtn->setFixedSize(24, 24);
245  connect(_pCopyBtn, &QToolButton::clicked, this, &TYModelerFrame::copy);
246 
247  // Btn Show Sources
248  _pShowSourcesBtn = new QToolButton(this);
249  _pShowSourcesBtn->setIcon(QPixmap(IMG("id_icon_source")));
250  _pShowSourcesBtn->setText(TR("id_show_source_btn"));
251  _pShowSourcesBtn->setToolTip(TR("id_show_source_btn"));
252  _pShowSourcesBtn->setCheckable(true);
253  _pShowSourcesBtn->setChecked(false);
254  _pShowSourcesBtn->setFixedSize(24, 24);
255  _pCtrlLayout->addWidget(_pShowSourcesBtn, 0);
256  connect(_pShowSourcesBtn, &QToolButton::toggled, this, &TYModelerFrame::showSources);
257  showSources();
258 
259  // Btn Show Normals
260  _pShowNormalsBtn = new QToolButton(this);
261  _pShowNormalsBtn->setIcon(QPixmap(IMG("id_icon_normals")));
262  _pShowNormalsBtn->setText(TR("id_show_normals_btn"));
263  _pShowNormalsBtn->setToolTip(TR("id_show_normals_btn"));
264  _pShowNormalsBtn->setCheckable(true);
265  _pShowNormalsBtn->setChecked(false);
266  _pShowNormalsBtn->setFixedSize(24, 24);
267  _pCtrlLayout->addWidget(_pShowNormalsBtn, 0);
268  connect(_pShowNormalsBtn, &QToolButton::toggled, this, &TYModelerFrame::showNormals);
269  showNormals(_pShowNormalsBtn->isChecked());
270 
271  // Btn Show Plafond
272  _pShowPlafondBtn = new QToolButton(this);
273  _pShowPlafondBtn->setIcon(QPixmap(IMG("id_icon_plafond")));
274  _pShowPlafondBtn->setText(TR("id_show_plafond_btn"));
275  _pShowPlafondBtn->setToolTip(TR("id_show_plafond_btn"));
276  _pShowPlafondBtn->setCheckable(true);
277  _pShowPlafondBtn->setChecked(false);
278  _pShowPlafondBtn->setFixedSize(24, 24);
279  _pCtrlLayout->addWidget(_pShowPlafondBtn, 0);
280  connect(_pShowPlafondBtn, &QToolButton::toggled, this, &TYModelerFrame::showPlafond);
281  showPlafond(_pShowPlafondBtn->isChecked());
282 
283  // Btn Show Rayons
284  _pShowRaysBtn = new QToolButton(this);
285  _pShowRaysBtn->setIcon(QPixmap(IMG("id_icon_rays")));
286  _pShowRaysBtn->setText(TR("id_show_rays_btn"));
287  _pShowRaysBtn->setToolTip(TR("id_show_rays_btn"));
288 
289  _pShowRaysBtn->setCheckable(true);
290  _pShowRaysBtn->setChecked(false);
291  _pShowRaysBtn->setFixedSize(24, 24);
292  _pCtrlLayout->addWidget(_pShowRaysBtn, 0);
293  connect(_pShowRaysBtn, &QToolButton::toggled, this, &TYModelerFrame::showRays);
294  showRays(_pShowRaysBtn->isChecked());
295 
296  // Vue graphique
297  _pView = new TYRenderWindowInteractor(this, "vue graphique");
298  _pLayout->addWidget(_pView, 1, 0);
299 
300  QObject::connect(_pView, &TYRenderWindowInteractor::mouseMoved, this, &TYModelerFrame::updateCurPosInfo);
301 
302  // Status bar
303  _pStatusBar = new QStatusBar(this);
304  _pLayout->addWidget(_pStatusBar, 2, 0);
305 
306  // Cameras pour chaque type de vue
307  QVector3D fromTop{0, 10000, 0};
308  QVector3D toTop{0, 0, 0};
309  QVector3D upTop{0, 0, -1};
310  _pOGLCameras[TopView] = new OGLCamera(fromTop, toTop, upTop, 100, 100, PARALLEL);
311 
312  QVector3D fromBottom{0, -10000, 0};
313  QVector3D toBottom{0, 0, 0};
314  QVector3D upBottom{0, 0, -1};
315  _pOGLCameras[BottomView] = new OGLCamera(fromBottom, toBottom, upBottom, 100, 100, PARALLEL);
316 
317  QVector3D fromLeft{-500, 0, 0};
318  QVector3D toLeft{0, 0, 0};
319  QVector3D upLeft{0, 1, 0};
320  _pOGLCameras[LeftView] = new OGLCamera(fromLeft, toLeft, upLeft, 100, 100, PARALLEL);
321 
322  QVector3D fromRight{500, 0, 0};
323  QVector3D toRight{0, 0, 0};
324  QVector3D upRight{0, 1, 0};
325  _pOGLCameras[RightView] = new OGLCamera(fromRight, toRight, upRight, 100, 100, PARALLEL);
326 
327  QVector3D fromFront{0, 0, 500};
328  QVector3D toFront{0, 0, 0};
329  QVector3D upFront{0, 1, 0};
330  _pOGLCameras[FrontView] = new OGLCamera(fromFront, toFront, upFront, 100, 100, PARALLEL);
331 
332  QVector3D fromRear{0, 0, -500};
333  QVector3D toRear{0, 0, 0};
334  QVector3D upRear{0, 1, 0};
335  _pOGLCameras[RearView] = new OGLCamera(fromRear, toRear, upRear, 100, 100, PARALLEL);
336 
337  QVector3D fromPersp{0, 10000, 10000};
338  QVector3D toPersp{0, 0, 0};
339  QVector3D upPersp{0, 1, 0};
340  _pOGLCameras[PerspView] = new OGLCamera(fromPersp, toPersp, upPersp, 100, 100, PERSPECTIVE);
341 
342  QVector3D fromFree{0, 0, 0};
343  QVector3D toFree{0, 0, 0.1};
344  QVector3D upFree{0, 1, 0};
345  _pOGLCameras[FreeView] = new OGLCamera(fromFree, toFree, upFree, 100, 100, FREE);
346 
347  // Triedre XYZ
348  _pOGLLineElementAxeX = new OGLLineElement();
349  _pOGLLineElementAxeX->setColor(OColor(0, 0, 1));
350  _pOGLLineElementAxeX->setVisibility(true);
351  _pOGLLineElementAxeX->setIs3D(true);
352  _pOGLLineElementAxeY = new OGLLineElement();
353  _pOGLLineElementAxeY->setColor(OColor(0, 0, 1));
354  _pOGLLineElementAxeY->setVisibility(true);
355  _pOGLLineElementAxeY->setIs3D(true);
356  _pOGLLineElementAxeZ = new OGLLineElement();
357  _pOGLLineElementAxeZ->setColor(OColor(0, 0, 1));
358  _pOGLLineElementAxeZ->setVisibility(true);
359  _pOGLLineElementAxeZ->setIs3D(true);
360 
361  _pOGLTextElementLabelX = new OGLTextElement();
362  _pOGLTextElementLabelX->setTextToDisplay("X");
363  _pOGLTextElementLabelX->setFont(IMG("id_font_bold"));
364  OColor oColor;
365  oColor.r = fontColor[0];
366  oColor.g = fontColor[1];
367  oColor.b = fontColor[2];
368  _pOGLTextElementLabelX->setColor(OColor(0, 0, 0));
369  _pOGLTextElementLabelX->setVisibility(true);
370 
371  _pOGLTextElementLabelY = new OGLTextElement();
372  _pOGLTextElementLabelY->setTextToDisplay("Y");
373  _pOGLTextElementLabelY->setFont(IMG("id_font_bold"));
374  _pOGLTextElementLabelY->setColor(OColor(0, 0, 0));
375  _pOGLTextElementLabelY->setVisibility(true);
376 
377  _pOGLTextElementLabelZ = new OGLTextElement();
378  _pOGLTextElementLabelZ->setTextToDisplay("Z");
379  _pOGLTextElementLabelZ->setFont(IMG("id_font_bold"));
380  _pOGLTextElementLabelZ->setColor(OColor(0, 0, 0));
381  _pOGLTextElementLabelZ->setVisibility(true);
382 
383  _pView->getRenderer()->addOGLElement(_pOGLLineElementAxeX);
384  _pView->getRenderer()->addOGLElement(_pOGLLineElementAxeY);
385  _pView->getRenderer()->addOGLElement(_pOGLLineElementAxeZ);
386  _pView->getRenderer()->addOGLElement(_pOGLTextElementLabelX);
387  _pView->getRenderer()->addOGLElement(_pOGLTextElementLabelY);
388  _pView->getRenderer()->addOGLElement(_pOGLTextElementLabelZ);
389 
390  // Label
391  _pOGLTextElement = new OGLTextElement();
392  _pOGLTextElement->setTextToDisplay("");
393  _pOGLTextElement->setFont(IMG("id_font_bold"));
394  _pOGLTextElement->setColor(oColor);
395  _pOGLTextElement->setVisibility(true);
396  _pView->getRenderer()->addOGLElement(_pOGLTextElement);
397 
398 #ifndef NO_GRID
399  // Construction de la grille
400  _pOGLGridElement = new OGLGridElement();
401  _pOGLGridElement->setColor(OColor(gridColor[0], gridColor[1], gridColor[2]));
402  _pOGLGridElement->setVisibility(true);
403  _pOGLGridElement->setIs3D(true);
404  _pView->getRenderer()->addOGLElement(_pOGLGridElement);
405 #endif // NO_GRID
406 
407  // Axes de la grille
408  _pOGLLineElementX = new OGLLineElement();
409  _pOGLLineElementX->setPoint1(QVector3D(-100, 0, 0));
410  _pOGLLineElementX->setPoint2(QVector3D(100, 0, 0));
411  _pOGLLineElementX->setColor(OColor(0, 0, 0));
412  _pOGLLineElementX->setVisibility(true);
413  _pOGLLineElementX->setIs3D(true);
414  _pOGLLineElementX->setLineWidth(2.0);
415 
416  _pOGLLineElementY = new OGLLineElement();
417  _pOGLLineElementY->setPoint1(QVector3D(0, -100, 0));
418  _pOGLLineElementY->setPoint2(QVector3D(0, 100, 0));
419  _pOGLLineElementY->setColor(OColor(0, 0, 0));
420  _pOGLLineElementY->setVisibility(true);
421  _pOGLLineElementY->setIs3D(true);
422  _pOGLLineElementY->setLineWidth(2.0);
423 
424  _pView->getRenderer()->addOGLElement(_pOGLLineElementX);
425  _pView->getRenderer()->addOGLElement(_pOGLLineElementY);
426 
427  // Echelle
428  _pOGLScalarBarElement = new OGLScalarBarElement();
429  _pOGLScalarBarElement->setPosition(QVector3D(100, 50, 0));
430  _pOGLScalarBarElement->setSizes(100, 8);
431  _pOGLScalarBarElement->initPositions();
432  _pOGLScalarBarElement->setFont(IMG("id_font"));
433  _pOGLScalarBarElement->setFontColor(OColor(0, 0, 0));
434  _pOGLScalarBarElement->setTexts("0", "0", "0");
435  _pOGLScalarBarElement->setVisibility(true);
436  _pView->getRenderer()->addOGLElement(_pOGLScalarBarElement);
437 
438  // Lumieres
439  _pLightElement = new OGLLightElement();
440  _pLightElement->init(0, OPoint3D(0.0, 400.0, 0.0), 1.0f);
441  _pView->getRenderer()->addLight(_pLightElement);
442 
443  // Couleur de fond
444  getRenderer()->setBackground(rendererColor);
445 
446  // Type de rendu
447  setRenderMode(TYOpenGLRenderer::Surface, true);
448 
449  _wireframeOnMovingCamera = false;
450  _lastRenderMode = getRenderMode();
451 
452  // Gestion du picking
453  _pPicker = new TYElementPicker(this);
454 
455  // Passage en vue de dessus.
456  setViewType(TopView);
457 
458  // Editors
459  _pCameraEditor = new TYCameraEditor(this);
460  _pCameraZoneEditor = new TYCameraZoneEditor(this);
461  _pDistanceEditor = new TYDistanceEditor(this);
462  _pPositionEditor = new TYPositionEditor(this);
463 
464  // Le pick editor
465  _pPickEditor = new TYPickEditor(this);
466  _pPickEditor->connect();
467 
468  // Mode d'edition
469  setEditorModeToCamera();
470 
471  resizeGrid();
472  showGrid(_pGridBtn->isChecked());
473  showScale(_pShowScale->isChecked());
474 
475  // Chargement des preferences
476  updatePreferences();
477 
478  showMaximized();
479 }
480 
481 TYModelerFrame::~TYModelerFrame()
482 {
483 
484  // Disambiguate the overloaded signal QComboBox::activated
485  void (QComboBox::*_qComboBox_activated)(int) = &QComboBox::activated;
486 
487  disconnect(_pViewTypeBox, _qComboBox_activated, this, &TYModelerFrame::setViewType);
488  disconnect(_pRenderModeBox, _qComboBox_activated, this, &TYModelerFrame::setRenderModeSlot);
489  disconnect(_pGridBtn, &QToolButton::toggled, this, &TYModelerFrame::showGrid);
490  disconnect(_pShowScale, &QToolButton::toggled, this, &TYModelerFrame::showScale);
491  disconnect(_pSnapGridBtn, &QToolButton::toggled, this, &TYModelerFrame::setSnapGridActive);
492  disconnect(_pSetCameraCoordinatesBtn, &QToolButton::clicked, this, &TYModelerFrame::setCameraCoordinates);
493  disconnect(_pScreenShotBtn, &QToolButton::clicked, this, &TYModelerFrame::screenShot);
494  disconnect(_pShowSourcesBtn, &QToolButton::toggled, this, &TYModelerFrame::showSources);
495  disconnect(_pShowNormalsBtn, &QToolButton::toggled, this, &TYModelerFrame::showNormals);
496  disconnect(_pShowPlafondBtn, &QToolButton::toggled, this, &TYModelerFrame::showPlafond);
497  disconnect(_pShowRaysBtn, &QToolButton::toggled, this, &TYModelerFrame::showRays);
498  disconnect(_pView, &TYRenderWindowInteractor::mouseMoved, this, &TYModelerFrame::updateCurPosInfo);
499 
500  delete _pCameraEditor;
501  delete _pCameraZoneEditor;
502  delete _pDistanceEditor;
503  delete _pPositionEditor;
504  delete _pPickEditor;
505  delete _pPicker;
506 
507  for (int i = 0; i < NbOfViews; i++)
508  {
509  delete _pOGLCameras[i];
510  _pOGLCameras[i] = NULL;
511  }
512 
513  _pView->getRenderer()->removeOGLElement(_pOGLLineElementAxeX);
514  delete _pOGLLineElementAxeX;
515  _pView->getRenderer()->removeOGLElement(_pOGLLineElementAxeY);
516  delete _pOGLLineElementAxeY;
517  _pView->getRenderer()->removeOGLElement(_pOGLLineElementAxeZ);
518  delete _pOGLLineElementAxeZ;
519  _pView->getRenderer()->removeOGLElement(_pOGLTextElementLabelX);
520  delete _pOGLTextElementLabelX;
521  _pView->getRenderer()->removeOGLElement(_pOGLTextElementLabelY);
522  delete _pOGLTextElementLabelY;
523  _pView->getRenderer()->removeOGLElement(_pOGLTextElementLabelZ);
524  delete _pOGLTextElementLabelZ;
525 
526  _pView->getRenderer()->removeOGLElement(_pOGLTextElement);
527  delete _pOGLTextElement;
528  _pView->getRenderer()->removeOGLElement(_pOGLScalarBarElement);
529  delete _pOGLScalarBarElement;
530  _pView->getRenderer()->removeOGLElement(_pOGLLineElementX);
531  delete _pOGLLineElementX;
532  _pView->getRenderer()->removeOGLElement(_pOGLLineElementY);
533  delete _pOGLLineElementY;
534 
535 #ifndef NO_GRID
536  _pView->getRenderer()->removeOGLElement(_pOGLGridElement);
537  delete _pOGLGridElement;
538 #endif // NO_GRID
539  _pView->getRenderer()->removeLights();
540  delete _pLightElement;
541  delete _pView;
542  _pView = nullptr;
543 }
544 
545 void TYModelerFrame::addScreenShotBtn()
546 {
547  _pCtrlLayout->addSpacing(7);
548  _pCtrlLayout->addWidget(_pScreenShotBtn, 0);
549  _pCtrlLayout->addWidget(_pCopyBtn, 0);
550 }
551 
552 bool TYModelerFrame::close()
553 {
554  return QWidget::close();
555 }
556 
557 bool TYModelerFrame::isElementInCurrentCalcul()
558 {
559  bool ret = false;
560 
561  if (getTYApp()->getCurProjet() && getTYApp()->getCurProjet()->getCurrentCalcul() && _pElement)
562  {
563  // L'element fait-il parti de la selection du calcul courant ?
564  ret = getTYApp()->getCurProjet()->getCurrentCalcul()->isInSelection(_pElement);
565  }
566 
567  return ret;
568 }
569 
570 bool TYModelerFrame::isElementInCurrentProjet()
571 {
572  bool ret = false;
573 
574  if (getTYApp()->getCurProjet() && _pElement)
575  {
576  // On commence directement a partir de l'element lui-meme
577  TYElement* pParent = _pElement;
578 
579  while (pParent)
580  {
581  // Le parent est le projet courant ?
582  if (pParent == getTYApp()->getCurProjet())
583  {
584  ret = true;
585  break;
586  }
587  // Parent du parent
588  pParent = pParent->getParent();
589  }
590  }
591 
592  return ret;
593 }
594 
595 bool TYModelerFrame::askForResetResultat()
596 {
597  bool ret = true;
598 
599  if (isElementInCurrentCalcul())
600  {
601  ret = getTYApp()->getCalculManager()->askForResetResultat();
602  }
603 
604  return ret;
605 }
606 
607 void TYModelerFrame::setViewType(int view)
608 {
609  if (view >= NbOfViews)
610  {
611  return;
612  }
613 
614  // View type
615  _curViewType = view;
616 
617  bool showGridXY = false;
618  bool showGridXZ = false;
619  bool showGridZY = false;
620  QString labelStr;
621 
622  // Pre traitement selon la vue activee
623  switch (view)
624  {
625  case TopView:
626  showGridXZ = _showGrid;
627  labelStr = TR("id_top_view");
628  _pSetCameraCoordinatesBtn->setEnabled(false);
629  break;
630  case BottomView:
631  showGridXZ = _showGrid;
632  labelStr = TR("id_bottom_view");
633  _pSetCameraCoordinatesBtn->setEnabled(false);
634  break;
635  case LeftView:
636  showGridZY = _showGrid;
637  labelStr = TR("id_left_view");
638  _pSetCameraCoordinatesBtn->setEnabled(false);
639  break;
640  case RightView:
641  showGridZY = _showGrid;
642  labelStr = TR("id_right_view");
643  _pSetCameraCoordinatesBtn->setEnabled(false);
644  break;
645  case FrontView:
646  showGridXY = _showGrid;
647  labelStr = TR("id_front_view");
648  _pSetCameraCoordinatesBtn->setEnabled(false);
649  break;
650  case RearView:
651  showGridXY = _showGrid;
652  labelStr = TR("id_rear_view");
653  _pSetCameraCoordinatesBtn->setEnabled(false);
654  break;
655  case PerspView:
656  showGridXZ = _showGrid;
657  labelStr = TR("id_3d_view");
658  _pSetCameraCoordinatesBtn->setEnabled(false);
659  break;
660  case FreeView:
661  showGridXZ = _showGrid;
662  labelStr = TR("id_free_view");
663  _pSetCameraCoordinatesBtn->setEnabled(true);
664  break;
665  default:
666  break;
667  }
668 
669  //_pView->setFocus();
670 
671  // Affichage de la grille correspondant au type de vue
672  setGridLinesActorsVisibility(showGridXY, showGridXZ, showGridZY);
673 
674  // Label
675  _pOGLTextElement->setTextToDisplay(labelStr);
676 
677  // Camera
678  OGLCamera* camera = _pOGLCameras[view];
679  _pView->setActiveCamera(camera);
680 
681  // Update l'element associe a ce modeler
682  if (_pElement)
683  {
684  _pElement->updateGraphicTree();
685  _pElement->getGraphicObject()->update(true);
686  }
687 
688  _pView->getRenderer()->invalidateScene();
689  // Updates
690  updateView();
691 
692  _pViewTypeBox->setCurrentIndex(_curViewType);
693  emit viewTypeChanged(_curViewType);
694 }
695 
696 void TYModelerFrame::setRenderModeSlot(int mode)
697 {
698  setRenderMode(static_cast<TYOpenGLRenderer::RenderMode>(mode), true);
699 }
700 
701 void TYModelerFrame::setRenderMode(TYOpenGLRenderer::RenderMode mode, bool bUpdateGL)
702 {
703  if (mode >= TYOpenGLRenderer::NbOfRenderMode)
704  {
705  return;
706  }
707 
708  _pView->getRenderer()->setRenderMode(mode);
709 
710  _pRenderModeBox->setCurrentIndex(mode);
711 
712  if (bUpdateGL == true)
713  {
714  _pView->update();
715  }
716 }
717 
718 void TYModelerFrame::setEditorMode(int mode)
719 {
720  if (!_editorModeAccepted)
721  {
722  getPickEditor()->usePopup(true);
723  getPickEditor()->useHighlight(false);
724 
725  if (_pCurrentEditor)
726  {
727  // We want to be sure that Camera will not zoom unwillingly before disconnecting signals
728  _pCameraEditor->stopCameraZoom();
729  _pCurrentEditor->disconnect();
730  _pCurrentEditor->close();
731  }
732 
733  _editorModeAccepted = true;
734 
735  switch (mode)
736  {
737  case CameraMode:
738  // fit();
739  getPickEditor()->useHighlight(true);
740  _pCurrentEditor = _pCameraEditor;
741  break;
742  case CameraZoneMode:
743  getPickEditor()->useHighlight(true);
744  _pCurrentEditor = _pCameraZoneEditor;
745  break;
746  case DistanceMode:
747  _pCurrentEditor = _pDistanceEditor;
748  break;
749  case MovingMode:
750  _pCurrentEditor = _pPositionEditor;
751  _pPositionEditor->setMode(TYPositionEditor::Moving);
752  break;
753  case RotationMode:
754  _pCurrentEditor = _pPositionEditor;
755  _pPositionEditor->setMode(TYPositionEditor::Rotation);
756  break;
757  case EditionMode:
758  _pCurrentEditor = _pPositionEditor;
759  _pPositionEditor->setMode(TYPositionEditor::Edition);
760  break;
761  case NoMode:
762  default:
763  getPickEditor()->useHighlight(true);
764  _pCurrentEditor = NULL;
765  mode = NoMode;
766  _editorModeAccepted = false;
767  break;
768  }
769  }
770 
771  // On sauve le mode courant
772  _lastEditorMode = mode;
773 
774  // Init
775  if (_pCurrentEditor)
776  {
777  _pCurrentEditor->connect();
778  _pCurrentEditor->init();
779  }
780 
781  // Pour la prochaine requete
782  _editorModeAccepted = false;
783 
784  // The bug goes by here...
785  emit(editorModeChanged(mode));
786 }
787 
788 void TYModelerFrame::showGrid(bool show)
789 {
790  _showGrid = show;
791 
792  _pOGLLineElementX->setVisibility(_showGrid);
793  _pOGLLineElementY->setVisibility(_showGrid);
794 
795  _pGridBtn->setChecked(_showGrid);
796 
797  _pView->getRenderer()->invalidateScene();
798  // Update
799  setViewType(_curViewType);
800 }
801 
802 void TYModelerFrame::showSources()
803 {
804  _showSources = _pShowSourcesBtn->isChecked();
805 
806  if ((_showSources != TYSourceLineicGraphic::_gVisible) ||
807  (_showSources != TYSourceSurfacicGraphic::_gVisible))
808  {
809 
810  TYApplication::setOverrideCursor(QCursor(Qt::WaitCursor));
811 
812  TYSourceLineicGraphic::_gVisible = _showSources;
813  TYSourceSurfacicGraphic::_gVisible = _showSources;
814 
815  if (_pElement && _pElement->getGraphicObject())
816  {
817  // Update l'element associe a ce modeler
818  _pElement->getGraphicObject()->update(true);
819 
820  _pView->getRenderer()->invalidateScene();
821 
822  // Update view
823  updateView();
824  }
825 
826  TYApplication::restoreOverrideCursor();
827  }
828 
829  _pShowSourcesBtn->setChecked(_showSources);
830 }
831 
832 void TYModelerFrame::showRays(bool show)
833 {
834  _showRays = show;
835  if (_showRays != TYRayGraphic::_gVisible)
836  {
837 
838  TYApplication::setOverrideCursor(QCursor(Qt::WaitCursor));
839 
840  TYRayGraphic::_gVisible = _showRays;
841 
842  if (_pElement && _pElement->getGraphicObject())
843  {
844  // Update l'element associe a ce modeler
845  _pElement->getGraphicObject()->update(true);
846 
847  _pView->getRenderer()->invalidateScene();
848 
849  // Update view
850  updateView();
851  }
852 
853  TYApplication::restoreOverrideCursor();
854  }
855 
856  _pShowRaysBtn->setChecked(_showRays);
857 }
858 
859 void TYModelerFrame::setKeepRays(bool keepRays)
860 {
861  _pShowRaysBtn->setEnabled(keepRays);
862 }
863 
864 void TYModelerFrame::showNormals(bool show)
865 {
866  _showNormals = show;
867 
868  if (_showNormals != TYElementGraphic::_gDrawNormals)
869  {
870 
871  TYApplication::setOverrideCursor(QCursor(Qt::WaitCursor));
872 
873  TYElementGraphic::_gDrawNormals = _showNormals;
874 
875  if (_pElement && _pElement->getGraphicObject())
876  {
877  // Update l'element associe a ce modeler
878  _pElement->getGraphicObject()->update(true);
879 
880  _pView->getRenderer()->invalidateScene();
881 
882  // Update view
883  updateView();
884  }
885 
886  TYApplication::restoreOverrideCursor();
887  }
888 
889  _pShowNormalsBtn->setChecked(_showNormals);
890 }
891 
892 void TYModelerFrame::showPlafond(bool show)
893 {
894  _showPlafond = !show; // inversion entre l'etat variable et du bouton
895 
896  if (_showPlafond != TYElementGraphic::_gDrawPlafond)
897  {
898 
899  TYApplication::setOverrideCursor(QCursor(Qt::WaitCursor));
900 
901  TYElementGraphic::_gDrawPlafond = _showPlafond;
902 
903  if (_pElement && _pElement->getGraphicObject())
904  {
905  // Update l'element associe a ce modeler
906  _pElement->getGraphicObject()->update(true);
907 
908  _pView->getRenderer()->invalidateScene();
909 
910  // Update view
911  updateView();
912  }
913 
914  TYApplication::restoreOverrideCursor();
915  }
916 
917  _pShowPlafondBtn->setChecked(!_showPlafond);
918 }
919 
920 void TYModelerFrame::setSnapGridActive(bool state)
921 {
922  _snapGridActive = state;
923  _pSnapGridBtn->setChecked(_snapGridActive);
924 }
925 
926 void TYModelerFrame::setCameraCoordinates()
927 {
928  if ((_pView->getActiveCamera()) && (_pView->getActiveCamera()->cameraType() == FREE))
929  {
930  TYSetCameraCoordinates* pSetCameraCoordinates = new TYSetCameraCoordinates(this);
931  double x = NAN, y = NAN, z = NAN;
932  _pView->getActiveCamera()->getTranslation(x, y, z);
933  pSetCameraCoordinates->setXCoord(x);
934  pSetCameraCoordinates->setYCoord(-z);
935  pSetCameraCoordinates->setZCoord(y);
936  pSetCameraCoordinates->exec();
937 
938  if (pSetCameraCoordinates->result() == QDialog::Accepted)
939  {
940  if (_pView->getActiveCamera())
941  {
942  _pView->getActiveCamera()->setTranslation(pSetCameraCoordinates->getXCoord(),
943  pSetCameraCoordinates->getZCoord(),
944  -pSetCameraCoordinates->getYCoord());
945 
946  // Update view
947  updateView();
948  }
949  }
950  }
951 }
952 
953 void TYModelerFrame::screenShot()
954 {
955  QString filename = QFileDialog::getSaveFileName(this, tr("Save Image"), "",
956  tr("Images PNG (*.png);;Images JPEG (*.jpg *.jpeg)"));
957  if (!filename.isEmpty())
958  {
959  // Snap
960  QImage img = _pView->grabFramebuffer();
961 
962  // Save
963  QPixmap pix = QPixmap::fromImage(img);
964  pix.save(filename);
965  }
966 }
967 
968 void TYModelerFrame::copy()
969 {
970  // Snap
971  QImage img = _pView->grabFramebuffer();
972 
973  // Copie dans le presse papier
974  QClipboard* clipboard = QApplication::clipboard();
975  clipboard->setImage(img);
976 }
977 
978 void TYModelerFrame::print()
979 {
980  LPTYProjet pProjet = getTYApp()->getCurProjet();
981  LPTYCalcul pCalcul = NULL;
982  if (pProjet)
983  {
984  pCalcul = pProjet->getCurrentCalcul();
985  }
986 
987  // Print dialog
988  TYPrintDialog* pDialog = new TYPrintDialog(this);
989 
990  if (pProjet == NULL)
991  {
992  pDialog->_groupBoxProjet->setEnabled(false);
993  }
994  if (pCalcul == NULL)
995  {
996  pDialog->_groupBoxCalcul->setEnabled(false);
997  }
998 
999  if (_pElement)
1000  {
1001  if (dynamic_cast<TYBatiment*>(_pElement._pObj) != nullptr)
1002  {
1003  pDialog->_groupBoxBatiment->show();
1004  }
1005  else if (dynamic_cast<TYMachine*>(_pElement._pObj) != nullptr)
1006  {
1007  pDialog->_groupBoxMachine->show();
1008  }
1009  else if (dynamic_cast<TYSiteNode*>(_pElement._pObj) != nullptr)
1010  {
1011  pDialog->_groupBoxSite->show();
1012  }
1013  }
1014 
1015  if (pDialog->exec() == QDialog::Accepted)
1016  {
1017  QPrinter* printer = new QPrinter();
1018 
1019  QPrintDialog dialog(printer, this);
1020  if (dialog.exec())
1021  {
1022  QPainter paint(printer);
1023 
1024  double w = double(printer->width());
1025  double h = double(printer->height());
1026  double scalew = w / 700;
1027  double scaleh = h / 700;
1028 
1029  // Snap
1030  QImage img = _pView->grabFramebuffer();
1031  img = img.scaled(int(w * 9 / 10), int(h * 2 / 3), Qt::KeepAspectRatio, Qt::SmoothTransformation);
1032  int x = int(double(printer->width() - img.width()) / 2);
1033  int y = int(double(printer->height() - img.height()) * 1 / 3);
1034  QPixmap pm = QPixmap::fromImage(img);
1035  paint.drawPixmap(x, y, pm);
1036 
1037  paint.setFont(QFont("Times", (int)(10 * scaleh)));
1038  int mid =
1039  int(w / 2) - int(paint.fontMetrics().horizontalAdvance(pDialog->_lineEditTete->text()) / 2);
1040  paint.drawText(mid, 20, pDialog->_lineEditTete->text());
1041 
1042  mid = int(w / 2) - int(paint.fontMetrics().horizontalAdvance(pDialog->_lineEditPied->text()) / 2);
1043  paint.drawText(mid, printer->height() - 20, pDialog->_lineEditPied->text());
1044 
1045  paint.setFont(QFont("Times", (int)(15 * scaleh), QFont::Bold));
1046  mid =
1047  int(w / 2) - int(paint.fontMetrics().horizontalAdvance(pDialog->_lineEditTitre->text()) / 2);
1048  paint.drawText(mid, y - 20, pDialog->_lineEditTitre->text());
1049 
1050  x = int(50 * scalew);
1051  int x1 = int(w / 2);
1052  y = int(double(printer->height()) * 2 / 3 + 20 * scaleh);
1053  int stepy = int(10 * scaleh);
1054  paint.setFont(QFont("Times", (int)(10 * scaleh)));
1055 
1056  if (pProjet)
1057  {
1058  if (pDialog->_checkBoxNomProjet->isChecked())
1059  {
1060  paint.drawText(x, y, TR("id_print_nom_projet"));
1061  paint.drawText(x1, y, pProjet->getName());
1062  y += stepy;
1063  }
1064  if (pDialog->_checkBoxAuteurProjet->isChecked())
1065  {
1066  paint.drawText(x, y, TR("id_print_auteur_projet"));
1067  paint.drawText(x1, y, pProjet->getAuteur());
1068  y += stepy;
1069  }
1070  if (pDialog->_checkBoxDateProjet->isChecked())
1071  {
1072  paint.drawText(x, y, TR("id_print_date_creation"));
1073  paint.drawText(x1, y, pProjet->getDateCreation());
1074  y += stepy;
1075  paint.drawText(x, y, TR("id_print_date_modif"));
1076  paint.drawText(x1, y, pProjet->getDateModif());
1077  y += stepy;
1078  }
1079  if (pDialog->_checkBoxCommentProjet->isChecked())
1080  {
1081  paint.drawText(x, y, TR("id_print_comment"));
1082  paint.drawText(x1, y, pProjet->getComment());
1083  y += stepy;
1084  }
1085  }
1086 
1087  if (pCalcul)
1088  {
1089  y += int(double(stepy) * 1.5);
1090  if (pDialog->_checkBoxNomCalcul->isChecked())
1091  {
1092  paint.drawText(x, y, TR("id_print_nom_calcul"));
1093  paint.drawText(x1, y, pCalcul->getName());
1094  y += stepy;
1095  }
1096  if (pDialog->_checkBoxDateCalcul->isChecked())
1097  {
1098  paint.drawText(x, y, TR("id_print_date_creation"));
1099  paint.drawText(x1, y, pCalcul->getDateCreation());
1100  y += stepy;
1101  paint.drawText(x, y, TR("id_print_date_modif"));
1102  paint.drawText(x1, y, pCalcul->getDateModif());
1103  y += stepy;
1104  }
1105  if (pDialog->_checkBoxCommentCalcul->isChecked())
1106  {
1107  paint.drawText(x, y, TR("id_print_comment"));
1108  paint.drawText(x1, y, pCalcul->getComment());
1109  y += stepy;
1110  }
1111  }
1112 
1113  if (_pElement)
1114  {
1115  y += int(double(stepy) * 1.5);
1116  TYElement* pElement = (TYElement*)_pElement;
1117  if (strcmp(_pElement->getClassName(), "TYBatiment") == 0)
1118  {
1119  TYBatiment* pBatiment = (TYBatiment*)pElement;
1120  if (pDialog->_checkBoxNomBatiment->isChecked())
1121  {
1122  paint.drawText(x, y, TR("id_print_nom_batiment"));
1123  paint.drawText(x1, y, pBatiment->getName());
1124  }
1125  }
1126  else if (strcmp(_pElement->getClassName(), "TYMachine") == 0)
1127  {
1128  TYMachine* pMachine = (TYMachine*)pElement;
1129  if (pDialog->_checkBoxNomMachine->isChecked())
1130  {
1131  paint.drawText(x, y, TR("id_print_nom_machine"));
1132  paint.drawText(x1, y, pMachine->getName());
1133  y += stepy;
1134  }
1135  if (pDialog->_checkBoxConstrMachine->isChecked())
1136  {
1137  paint.drawText(x, y, TR("id_print_constr"));
1138  paint.drawText(x1, y, pMachine->getConstructeur());
1139  y += stepy;
1140  }
1141  if (pDialog->_checkBoxModelMachine->isChecked())
1142  {
1143  paint.drawText(x, y, TR("id_print_model"));
1144  paint.drawText(x1, y, pMachine->getModele());
1145  y += stepy;
1146  }
1147  if (pDialog->_checkBoxCatMachine->isChecked())
1148  {
1149  paint.drawText(x, y, TR("id_print_cat"));
1150  paint.drawText(x1, y, QString().setNum(pMachine->getCategorie()));
1151  y += stepy;
1152  }
1153  if (pDialog->_checkBoxCommentProjet->isChecked())
1154  {
1155  paint.drawText(x, y, TR("id_print_comment"));
1156  paint.drawText(x1, y, pMachine->getCommentaire());
1157  }
1158  }
1159  else
1160  {
1161  TYSiteNode* pSite = dynamic_cast<TYSiteNode*>(pElement);
1162  if (pSite != nullptr)
1163  {
1164  if (pDialog->_checkBoxNomSite->isChecked())
1165  {
1166  paint.drawText(x, y, TR("id_print_nom_site"));
1167  paint.drawText(x1, y, pSite->getName());
1168  }
1169  }
1170  }
1171  }
1172  }
1173 
1174  delete printer;
1175  }
1176 }
1177 
1178 void TYModelerFrame::editElement()
1179 {
1180  if (_pElement)
1181  {
1182  if (_pElement->edit(this) == QDialog::Accepted)
1183  {
1184  emit eltModified(_pElement);
1185  }
1186 
1187  // On update ds ts les cas si un child a ete modifie...
1188  _pElement->getGraphicObject()->update(true);
1189  _pView->getRenderer()->invalidateScene();
1190  updateView(false, false);
1191  }
1192 }
1193 
1194 OBox getBoundingBox(TYElement* pElement)
1195 {
1196  // XBH: version simplifiee et +logique...
1197 
1198  OBox boundingBox;
1199  LPTYElementGraphic pTYElementGraphic = pElement->getGraphicObject();
1200 
1201  if (pTYElementGraphic != NULL)
1202  {
1203  boundingBox = pTYElementGraphic->boundingBox();
1204  }
1205 
1206  return boundingBox;
1207 }
1208 
1209 OBox TYModelerFrame::getGlobalBoundingBox()
1210 {
1211  OBox globalBoundingBox;
1212  if (_pElement)
1213  {
1214  TYElement* pTYElement = (TYElement*)_pElement;
1215  TYProjet* pTYProjet = dynamic_cast<TYProjet*>(pTYElement);
1216  if (pTYProjet != nullptr)
1217  {
1218  TYSiteNode* pTYSiteNode = (TYSiteNode*)pTYProjet->getSite();
1219  pTYElement = pTYSiteNode;
1220  }
1221 
1222  globalBoundingBox = getBoundingBox(pTYElement);
1223  }
1224  return globalBoundingBox;
1225 }
1226 
1227 void TYModelerFrame::fit()
1228 {
1229  for (auto camera : _pOGLCameras)
1230  {
1231  camera->setSize(_pView->getViewport().width(), _pView->getViewport().height());
1232  }
1233 
1234  int visibilityStates[9];
1235 
1236  // Sauvegarde des etats de visibilite des objets graphiques
1237  // de "decoration", ils ne doivent pas participer au recadrage
1238 #ifndef NO_GRID
1239  visibilityStates[0] = _pOGLGridElement->getShowGridXY();
1240  visibilityStates[1] = _pOGLGridElement->getShowGridXZ();
1241  visibilityStates[2] = _pOGLGridElement->getShowGridZY();
1242 #endif // NO_GRID
1243 
1244  setGridLinesActorsVisibility(false, false, false);
1245 
1246  visibilityStates[3] = _pOGLLineElementAxeX->getVisibility();
1247  _pOGLLineElementAxeX->setVisibility(false);
1248  _pOGLLineElementAxeY->setVisibility(false);
1249  _pOGLLineElementAxeZ->setVisibility(false);
1250  visibilityStates[4] = _pOGLTextElementLabelX->getVisibility();
1251  _pOGLTextElementLabelX->setVisibility(false);
1252  visibilityStates[5] = _pOGLTextElementLabelY->getVisibility();
1253  _pOGLTextElementLabelY->setVisibility(false);
1254  visibilityStates[6] = _pOGLTextElementLabelZ->getVisibility();
1255  _pOGLTextElementLabelZ->setVisibility(false);
1256 
1257  visibilityStates[7] = _pOGLLineElementX->getVisibility();
1258  _pOGLLineElementX->setVisibility(false);
1259  visibilityStates[8] = _pOGLLineElementY->getVisibility();
1260  _pOGLLineElementY->setVisibility(false);
1261 
1262  // az-- : pour tests reperes machines:
1263  OBox globalBoundingBox = getGlobalBoundingBox();
1264 
1265  float xMin = globalBoundingBox._min._x;
1266  float xMax = globalBoundingBox._max._x;
1267  float yMin = globalBoundingBox._min._y;
1268  float yMax = globalBoundingBox._max._y;
1269  float zMin = globalBoundingBox._min._z;
1270  float zMax = globalBoundingBox._max._z;
1271  float xDist = std::max(abs(xMin), abs(xMax)) * 2;
1272  float yDist = std::max(abs(yMin), abs(yMax)) * 2;
1273  float zDist = std::max(abs(zMin), abs(zMax)) * 2;
1274 
1275  // Cameras pour chaque type de vue
1276  QVector3D fromTop{0, 10000, 0};
1277  QVector3D toTop{0, 0, 0};
1278  QVector3D upTop{0, 0, -1};
1279  _pOGLCameras[TopView]->setFromToUp(fromTop, toTop, upTop);
1280  _pOGLCameras[TopView]->resetRotations();
1281  _pOGLCameras[TopView]->resetZoom(xDist, yDist);
1282 
1283  QVector3D fromBottom{0, -10000, 0};
1284  QVector3D toBottom{0, 0, 0};
1285  QVector3D upBottom{0, 0, 1};
1286  _pOGLCameras[BottomView]->setFromToUp(fromBottom, toBottom, upBottom);
1287  _pOGLCameras[BottomView]->resetRotations();
1288  _pOGLCameras[BottomView]->resetZoom(xDist, yDist);
1289 
1290  QVector3D fromLeft{-500, 0, 0};
1291  QVector3D toLeft{0, 0, 0};
1292  QVector3D upLeft{0, 1, 0};
1293  _pOGLCameras[LeftView]->setFromToUp(fromLeft, toLeft, upLeft);
1294  _pOGLCameras[LeftView]->resetZoom(yDist, zDist);
1295 
1296  QVector3D fromRight{500, 0, 0};
1297  QVector3D toRight{0, 0, 0};
1298  QVector3D upRight{0, 1, 0};
1299  _pOGLCameras[RightView]->setFromToUp(fromRight, toRight, upRight);
1300  _pOGLCameras[RightView]->resetZoom(yDist, zDist);
1301 
1302  QVector3D fromFront{0, 0, 500};
1303  QVector3D toFront{0, 0, 0};
1304  QVector3D upFront{0, 1, 0};
1305  _pOGLCameras[FrontView]->setFromToUp(fromFront, toFront, upFront);
1306  _pOGLCameras[FrontView]->resetZoom(xDist, zDist);
1307 
1308  QVector3D fromRear{0, 0, -500};
1309  QVector3D toRear{0, 0, 0};
1310  QVector3D upRear{0, 1, 0};
1311  _pOGLCameras[RearView]->setFromToUp(fromRear, toRear, upRear);
1312  _pOGLCameras[RearView]->resetZoom(xDist, zDist);
1313 
1314  QVector3D fromPersp{0, 1000, 1000};
1315  QVector3D toPersp{0, 0, 0};
1316  QVector3D upPersp{0, 1, 0};
1317  _pOGLCameras[PerspView]->setFromToUp(fromPersp, toPersp, upPersp);
1318  _pOGLCameras[PerspView]->resetZoom(xDist, yDist);
1319  _pOGLCameras[PerspView]->resetRotations();
1320  _pOGLCameras[PerspView]->setDistanceStep(30, 70, 30);
1321 
1322  QVector3D fromFree{0, 0, 0};
1323  QVector3D toFree{0, 0, 0.1};
1324  QVector3D upFree{0, 1, 0};
1325  _pOGLCameras[FreeView]->setFromToUp(fromFree, toFree, upFree);
1326  _pOGLCameras[FreeView]->resetZoom();
1327  _pOGLCameras[FreeView]->resetRotations();
1328  _pOGLCameras[FreeView]->setTranslation(0, 2, 0);
1329  _pOGLCameras[FreeView]->setDistanceStep(5, 5, 5);
1330 
1331  // Restauration des etats de visibilite des objets graphiques
1332 #ifndef NO_GRID
1333  setGridLinesActorsVisibility(visibilityStates[0], visibilityStates[1], visibilityStates[2]);
1334 #endif // NO_GRID
1335  _pOGLLineElementAxeX->setVisibility(visibilityStates[3]);
1336  _pOGLLineElementAxeY->setVisibility(visibilityStates[3]);
1337  _pOGLLineElementAxeZ->setVisibility(visibilityStates[3]);
1338  _pOGLTextElementLabelX->setVisibility(visibilityStates[4]);
1339  _pOGLTextElementLabelY->setVisibility(visibilityStates[5]);
1340  _pOGLTextElementLabelZ->setVisibility(visibilityStates[6]);
1341  _pOGLLineElementX->setVisibility(visibilityStates[7]);
1342  _pOGLLineElementY->setVisibility(visibilityStates[8]);
1343 
1344  _pView->getRenderer()->invalidateScene();
1345  updateView();
1346 }
1347 
1348 void TYModelerFrame::updateView(bool clipping /*=true*/, bool axesAndGrid /*=true*/)
1349 {
1350  OGLCamera* activeCamera = _pView->getActiveCamera();
1351  if (activeCamera)
1352  {
1353  QRect viewport = _pView->getViewport();
1354  activeCamera->setSize(viewport.width(), viewport.height());
1355  if (axesAndGrid)
1356  {
1357  updateAxes();
1358  updateGrid();
1359  updateCurPosInfo(0, 0);
1360  updateScale();
1361  }
1362 
1363  if (clipping)
1364  {
1365  // Update le render mode
1366  setRenderMode(getRenderMode(), false);
1367  }
1368  _pOGLTextElement->setDisplayPosition(7, viewport.height() - 20);
1369  _pOGLScalarBarElement->setPosition(
1370  QVector3D(viewport.width() - _pOGLScalarBarElement->getWidth() * 0.5 - 50, 50, 0));
1371  _pOGLScalarBarElement->initPositions();
1372 
1373  // RNU
1374  //_pView->getRenderer()->invalidateScene();
1375 
1376  // Update la vue 3D
1377  _pView->update();
1378  }
1379 }
1380 
1381 void TYModelerFrame::updateAxes()
1382 {
1383  _pOGLLineElementAxeX->setVisibility(true);
1384  _pOGLLineElementAxeY->setVisibility(true);
1385  _pOGLLineElementAxeZ->setVisibility(true);
1386  _pOGLTextElementLabelX->setVisibility(true);
1387  _pOGLTextElementLabelY->setVisibility(true);
1388  _pOGLTextElementLabelZ->setVisibility(true);
1389 
1390  QVector3D org = _pView->getViewport().displayToWorld(QVector3D(50, 50, 0.1));
1391 
1392  _pOGLLineElementAxeX->setPoint1(org);
1393  _pOGLLineElementAxeY->setPoint1(org);
1394  _pOGLLineElementAxeZ->setPoint1(org);
1395 
1396  QVector3D extX, extY, extZ;
1397 
1398  switch (getCurrentView())
1399  {
1400  case TopView:
1401  {
1402  extX = _pView->getViewport().displayToWorld(QVector3D(90, 50, 0.1));
1403  extY = _pView->getViewport().displayToWorld(QVector3D(50, 90, 0.1));
1404  extZ = _pView->getViewport().displayToWorld(QVector3D(50, 50, 40.1));
1405  _pOGLTextElementLabelX->setDisplayPosition(90, 50);
1406  _pOGLTextElementLabelY->setDisplayPosition(50, 90);
1407  _pOGLTextElementLabelZ->setDisplayPosition(52, 50);
1408  }
1409  break;
1410  case BottomView:
1411  {
1412  extX = _pView->getViewport().displayToWorld(QVector3D(10, 50, 0.1));
1413  extY = _pView->getViewport().displayToWorld(QVector3D(50, 90, 0.1));
1414  extZ = _pView->getViewport().displayToWorld(QVector3D(50, 50, -40.1));
1415  _pOGLTextElementLabelX->setDisplayPosition(10, 50);
1416  _pOGLTextElementLabelY->setDisplayPosition(50, 90);
1417  _pOGLTextElementLabelZ->setDisplayPosition(52, 50);
1418  }
1419  break;
1420  case LeftView:
1421  {
1422  extX = _pView->getViewport().displayToWorld(QVector3D(50, 50, 40.1));
1423  extY = _pView->getViewport().displayToWorld(QVector3D(10, 50, 0.1));
1424  extZ = _pView->getViewport().displayToWorld(QVector3D(50, 90, 0.1));
1425  _pOGLTextElementLabelX->setDisplayPosition(52, 50);
1426  _pOGLTextElementLabelY->setDisplayPosition(10, 50);
1427  _pOGLTextElementLabelZ->setDisplayPosition(50, 90);
1428  }
1429  break;
1430  case RightView:
1431  {
1432  extX = _pView->getViewport().displayToWorld(QVector3D(50, 50, -40.1));
1433  extY = _pView->getViewport().displayToWorld(QVector3D(90, 50, 0.1));
1434  extZ = _pView->getViewport().displayToWorld(QVector3D(50, 90, 0.1));
1435  _pOGLTextElementLabelX->setDisplayPosition(52, 50);
1436  _pOGLTextElementLabelY->setDisplayPosition(90, 50);
1437  _pOGLTextElementLabelZ->setDisplayPosition(50, 90);
1438  }
1439  break;
1440  case FrontView:
1441  {
1442  extX = _pView->getViewport().displayToWorld(QVector3D(90, 50, 0.1));
1443  extY = _pView->getViewport().displayToWorld(QVector3D(50, 50, 40.1));
1444  extZ = _pView->getViewport().displayToWorld(QVector3D(50, 90, 0.1));
1445  _pOGLTextElementLabelX->setDisplayPosition(90, 50);
1446  _pOGLTextElementLabelY->setDisplayPosition(52, 50);
1447  _pOGLTextElementLabelZ->setDisplayPosition(50, 90);
1448  }
1449  break;
1450  case RearView:
1451  {
1452  extX = _pView->getViewport().displayToWorld(QVector3D(10, 50, 0.1));
1453  extY = _pView->getViewport().displayToWorld(QVector3D(50, 50, -40.1));
1454  extZ = _pView->getViewport().displayToWorld(QVector3D(50, 90, 0.1));
1455  _pOGLTextElementLabelX->setDisplayPosition(10, 50);
1456  _pOGLTextElementLabelY->setDisplayPosition(52, 50);
1457  _pOGLTextElementLabelZ->setDisplayPosition(50, 90);
1458  }
1459  break;
1460  case PerspView:
1461  case FreeView:
1462  {
1463  QVector3D org2 = _pView->getViewport().displayToWorld(QVector3D(50, 90, 0.1));
1464  double dist = org.distanceToPoint(org2);
1465  extX.setX(org.x() + dist);
1466  extX.setY(org.y());
1467  extX.setZ(org.z());
1468  extY.setX(org.x());
1469  extY.setY(org.y());
1470  extY.setZ(org.z() - dist);
1471  extZ.setX(org.x());
1472  extZ.setY(org.y() + dist);
1473  extZ.setZ(org.z());
1474 
1475  QVector3D dispX = _pView->getViewport().worldToDisplay(extX);
1476  QVector3D dispY = _pView->getViewport().worldToDisplay(extY);
1477  QVector3D dispZ = _pView->getViewport().worldToDisplay(extZ);
1478 
1479  _pOGLTextElementLabelX->setDisplayPosition(dispX.x(), dispX.y());
1480  _pOGLTextElementLabelY->setDisplayPosition(dispY.x(), dispY.y());
1481  _pOGLTextElementLabelZ->setDisplayPosition(dispZ.x(), dispZ.y());
1482  }
1483  break;
1484  }
1485 
1486  _pOGLLineElementAxeX->setPoint2(extX);
1487  _pOGLLineElementAxeY->setPoint2(extY);
1488  _pOGLLineElementAxeZ->setPoint2(extZ);
1489 }
1490 
1491 void TYModelerFrame::keyPressEvent(QKeyEvent* pEvent)
1492 {
1493  switch (pEvent->key())
1494  {
1495  case Qt::Key_1:
1496  setViewType(TopView);
1497  break;
1498  case Qt::Key_2:
1499  setViewType(LeftView);
1500  break;
1501  case Qt::Key_3:
1502  setViewType(FrontView);
1503  break;
1504  case Qt::Key_4:
1505  setViewType(PerspView);
1506  break;
1507  case Qt::Key_5:
1508  setViewType(FreeView);
1509  break;
1510  case Qt::Key_V:
1511  setViewType((getCurrentView() + 1) % NbOfViews);
1512  break;
1513  case Qt::Key_I:
1514  _pView->showInfos(!_pView->getShowInfos());
1515  break;
1516  case Qt::Key_G:
1517  showGrid(!_showGrid);
1518  break;
1519  case Qt::Key_R:
1520  {
1521  int nextRenderMode = (getRenderMode() + 1) % TYOpenGLRenderer::NbOfRenderMode;
1522  setRenderMode(static_cast<TYOpenGLRenderer::RenderMode>(nextRenderMode), true);
1523  break;
1524  }
1525  case Qt::Key_W:
1526  setRenderMode(TYOpenGLRenderer::Wireframe, true);
1527  break;
1528  case Qt::Key_S:
1529  setRenderMode(TYOpenGLRenderer::Surface, true);
1530  break;
1531  case Qt::Key_Control:
1532  setSnapGridActive(false);
1533  break;
1534  case Qt::Key_C:
1535  if (pEvent->modifiers() == Qt::ControlModifier)
1536  {
1537  copy();
1538  }
1539  else
1540  {
1541  setEditorModeToCamera();
1542  }
1543  break;
1544  case Qt::Key_F:
1545  case Qt::Key_F5:
1546  fit();
1547  break;
1548  default:
1549  TYApplication::sendEvent(_pView, pEvent);
1550  }
1551 }
1552 
1553 void TYModelerFrame::keyReleaseEvent(QKeyEvent* pEvent)
1554 {
1555  switch (pEvent->key())
1556  {
1557  case Qt::Key_Control:
1558  setSnapGridActive(true);
1559  break;
1560  default:
1561  TYApplication::sendEvent(_pView, pEvent);
1562  }
1563 }
1564 
1565 void TYModelerFrame::mouseMoveEvent(QMouseEvent* pEvent) {}
1566 
1567 void TYModelerFrame::updateCurPosInfo(int x, int y)
1568 {
1569  // On recupere la pos du curseur
1570 
1571  // Calcul des coords
1572  float* pos = new float[3];
1573 
1574  if (computeCurPos(x, y, pos))
1575  {
1576  // Si la grille magnetique est activee
1577  if (getSnapGridActive())
1578  {
1579  TYAbstractSceneEditor::snapToGrid(pos[0], pos[1], pos[2], _gridMagnStep);
1580  }
1581 
1582  // Formatage du msg
1583  QString msg("pos : (%1, %2, %3)");
1584  // On inverse y et z, et -y... (VTK to TY)
1585  msg = msg.arg(pos[0], 0, 'f', 2).arg(-pos[2], 0, 'f', 2).arg(pos[1], 0, 'f', 2);
1586  // Affichage
1587  statusBar()->showMessage(msg);
1588  }
1589  else
1590  {
1591  if (getCurrentView() == FreeView)
1592  {
1593  double x = NAN, y = NAN, z = NAN;
1594  _pView->getActiveCamera()->getTranslation(x, y, z);
1595  QString msg = QString("camera pos : (%1, %2, %3)").arg(x).arg(-z).arg(y);
1596  statusBar()->showMessage(msg);
1597  }
1598  else
1599  {
1600  statusBar()->showMessage("");
1601  }
1602  }
1603 
1604  delete[] pos;
1605 }
1606 
1607 // float* TYModelerFrame::computeCurPos(int x, int y)
1608 bool TYModelerFrame::computeCurPos(int x, int y, float* ret)
1609 {
1610  int view = getCurrentView();
1611  if ((view != PerspView) && (view != FreeView))
1612  {
1613  // Position du curseur
1614  QVector3D pos =
1615  _pView->getViewport().displayToWorld(QVector3D(x, _pView->getViewport().height() - y, 0));
1616  ret[0] = pos.x();
1617  ret[1] = pos.y();
1618  ret[2] = pos.z();
1619 
1620  switch (getCurrentView())
1621  {
1622  case TopView:
1623  ret[1] = 0.0;
1624  break;
1625  case BottomView:
1626  ret[1] = 0.0;
1627  break;
1628  case LeftView:
1629  ret[0] = 0.0;
1630  break;
1631  case RightView:
1632  ret[0] = 0.0;
1633  break;
1634  case FrontView:
1635  ret[2] = 0.0;
1636  break;
1637  case RearView:
1638  ret[2] = 0.0;
1639  break;
1640  }
1641 
1642  return true;
1643  }
1644 
1645  return false;
1646 }
1647 
1648 float TYModelerFrame::getDefaultZCoord()
1649 {
1650  return _defaultZCoord;
1651 }
1652 
1653 void TYModelerFrame::setGridLinesActorsVisibility(bool showGridXY, bool showGridXZ, bool showGridZY)
1654 {
1655 #ifndef NO_GRID
1656  _pOGLGridElement->setShowGridXY(showGridXY);
1657  _pOGLGridElement->setShowGridXZ(showGridXZ);
1658  _pOGLGridElement->setShowGridZY(showGridZY);
1659 #endif // NO_GRID
1660 }
1661 
1662 void TYModelerFrame::wheelEvent(QWheelEvent* pEvent)
1663 {
1664  // Reroute l'event sur le TYRenderWindowInteractor
1665  TYApplication::sendEvent(_pView, pEvent);
1666 }
1667 
1668 void TYModelerFrame::resizeEvent(QResizeEvent* pEvent)
1669 {
1670  // CLM-NT33 : maximized handling and main window title
1671  emit frameResized();
1672  updateView();
1673 }
1674 
1675 void TYModelerFrame::focusInEvent(QFocusEvent* pEvent)
1676 {
1677  updateView();
1678 }
1679 
1680 void TYModelerFrame::showEvent(QShowEvent* pEvent)
1681 {
1682  if (_firstTimeShown)
1683  {
1684  TYPreferenceManager::loadGeometryFromPreferences(metaObject()->className(), this);
1685  _firstTimeShown = false;
1686  }
1687  updateView();
1688 }
1689 
1690 void TYModelerFrame::closeEvent(QCloseEvent* pEvent)
1691 {
1692  TYPreferenceManager::saveGeometryToPreferences(metaObject()->className(), this);
1693  pEvent->accept();
1694  emit frameResized();
1695  emit aboutToClose();
1696 
1697  // CLM-NT35 : Gestion du maximized et titre fenetre principal
1698 }
1699 
1700 void TYModelerFrame::enterEvent(QEvent* pEvent)
1701 {
1702  /* _pView->getRenderer()->invalidateScene();
1703  updateView();
1704  _pView->getRenderer()->invalidateScene();
1705  updateView();*/
1706  emit mouseEnter();
1707 }
1708 
1709 void TYModelerFrame::leaveEvent(QEvent* pEvent)
1710 {
1711  emit mouseLeave();
1712 }
1713 
1714 void TYModelerFrame::updateGrid()
1715 {
1716  if ((getCurrentView() == PerspView) || (getCurrentView() == FreeView))
1717  {
1718  _pOGLLineElementX->setPoint1(QVector3D(0, 0, _gridDimY / 2));
1719  _pOGLLineElementX->setPoint2(QVector3D(0, 0, -_gridDimY / 2));
1720 
1721  _pOGLLineElementY->setPoint1(QVector3D(_gridDimX / 2, 0, 0));
1722  _pOGLLineElementY->setPoint2(QVector3D(-_gridDimX / 2, 0, 0));
1723  }
1724  else
1725  {
1726  QRect viewport = _pView->getViewport();
1727  int gridXMax = viewport.width();
1728  int gridYMax = viewport.height();
1729  if (gridXMax == 0)
1730  {
1731  gridXMax = 100;
1732  }
1733  if (gridYMax == 0)
1734  {
1735  gridYMax = 100;
1736  }
1737 
1738  // getCenter
1739  QVector3D center = _pView->getViewport().worldToDisplay(QVector3D(0, 0, 0));
1740 
1741  // X
1742  QVector3D xAxisPoint1 = _pView->getViewport().displayToWorld(QVector3D(center.x(), 0, 0));
1743  QVector3D xAxisPoint2 = _pView->getViewport().displayToWorld(QVector3D(center.x(), gridYMax, 0));
1744  _pOGLLineElementX->setPoint1(xAxisPoint1);
1745  if (xAxisPoint1 != xAxisPoint2)
1746  {
1747  _pOGLLineElementX->setPoint2(xAxisPoint2);
1748  }
1749 
1750  // Y
1751  QVector3D yAxisPoint1 = _pView->getViewport().displayToWorld(QVector3D(0, center.y(), 0));
1752  QVector3D yAxisPoint2 = _pView->getViewport().displayToWorld(QVector3D(gridXMax, center.y(), 0));
1753  _pOGLLineElementY->setPoint1(yAxisPoint1);
1754  if (yAxisPoint1 != yAxisPoint2)
1755  {
1756  _pOGLLineElementY->setPoint2(yAxisPoint2);
1757  }
1758  }
1759 }
1760 
1761 void TYModelerFrame::updateElementGraphic(bool force /* = false */)
1762 {
1763  if (_pElement && _pElement->getGraphicObject())
1764  {
1765  _pElement->getGraphicObject()->update(force);
1766  }
1767 }
1768 
1769 void TYModelerFrame::resizeGrid()
1770 {
1771  _pOGLGridElement->setGridDimX(_gridDimX);
1772  _pOGLGridElement->setGridDimY(_gridDimY);
1773  _pOGLGridElement->setGridStep(_gridStep);
1774 
1775  _pOGLLineElementX->setColor(OColor(gridColor[0], gridColor[1], gridColor[2]));
1776  _pOGLLineElementY->setColor(OColor(gridColor[0], gridColor[1], gridColor[2]));
1777 }
1778 
1779 void TYModelerFrame::updatePreferences()
1780 {
1781  // Mise a jour de la taille de l'historique de l'Action Manager
1782  if (TYPreferenceManager::exists(TYDIRPREFERENCEMANAGER, "HistoSize"))
1783  {
1784  _actionManager.setHistorySize(TYPreferenceManager::getInt(TYDIRPREFERENCEMANAGER, "HistoSize"));
1785  }
1786  else
1787  {
1788  TYPreferenceManager::setInt(TYDIRPREFERENCEMANAGER, "HistoSize", _actionManager.getHistorySize());
1789  }
1790 
1791  // Mise a jour de l'etat d'activation du delplacement de camera en mode Wireframe
1792  if (TYPreferenceManager::exists(TYDIRPREFERENCEMANAGER, "WireframeOnMovingCamera"))
1793  {
1794  setWireframeOnMovingCamera(
1795  TYPreferenceManager::getBool(TYDIRPREFERENCEMANAGER, "WireframeOnMovingCamera"));
1796  }
1797  else
1798  {
1799  TYPreferenceManager::setBool(TYDIRPREFERENCEMANAGER, "WireframeOnMovingCamera", false);
1800  setWireframeOnMovingCamera(false);
1801  }
1802 
1803  // Mise a jour des couleurs a partir des preferences.
1804  // Couleur de fond
1805  if (TYPreferenceManager::exists(TYDIRPREFERENCEMANAGER, "BackgroundColorR"))
1806  {
1807  float r = NAN, g = NAN, b = NAN;
1808  TYPreferenceManager::getColor(TYDIRPREFERENCEMANAGER, "BackgroundColor", r, g, b);
1809  rendererColor[0] = r / 255;
1810  rendererColor[1] = g / 255;
1811  rendererColor[2] = b / 255;
1812  }
1813  else
1814  {
1815  float r = rendererColor[0] * 255;
1816  float g = rendererColor[1] * 255;
1817  float b = rendererColor[2] * 255;
1818  TYPreferenceManager::setColor(TYDIRPREFERENCEMANAGER, "BackgroundColor", r, g, b);
1819  }
1820 
1821  getRenderer()->setBackground(rendererColor);
1822 
1823  // Couleur de la grille
1824  if (TYPreferenceManager::exists(TYDIRPREFERENCEMANAGER, "GridColorR"))
1825  {
1826  float r = NAN, g = NAN, b = NAN;
1827  TYPreferenceManager::getColor(TYDIRPREFERENCEMANAGER, "GridColor", r, g, b);
1828  gridColor[0] = r / 255;
1829  gridColor[1] = g / 255;
1830  gridColor[2] = b / 255;
1831  }
1832  else
1833  {
1834  float r = gridColor[0] * 255;
1835  float g = gridColor[1] * 255;
1836  float b = gridColor[2] * 255;
1837  TYPreferenceManager::setColor(TYDIRPREFERENCEMANAGER, "GridColor", r, g, b);
1838  }
1839 
1840  // Couleur de la police
1841  if (TYPreferenceManager::exists(TYDIRPREFERENCEMANAGER, "FontColorR"))
1842  {
1843  float r = NAN, g = NAN, b = NAN;
1844  TYPreferenceManager::getColor(TYDIRPREFERENCEMANAGER, "FontColor", r, g, b);
1845  fontColor[0] = r / 255;
1846  fontColor[1] = g / 255;
1847  fontColor[2] = b / 255;
1848  }
1849  else
1850  {
1851  float r = fontColor[0] * 255;
1852  float g = fontColor[1] * 255;
1853  float b = fontColor[2] * 255;
1854  TYPreferenceManager::setColor(TYDIRPREFERENCEMANAGER, "FontColor", r, g, b);
1855  }
1856 
1857  _pOGLTextElementLabelX->setColor(OColor(0, 0, 0));
1858  _pOGLTextElementLabelY->setColor(OColor(0, 0, 0));
1859  _pOGLTextElementLabelZ->setColor(OColor(0, 0, 0));
1860  _pOGLScalarBarElement->setFontColor(OColor(fontColor[0], fontColor[1], fontColor[2]));
1861 
1862  // Mise a jour de l'eclairage de la scene.
1863  float intensity = 0.83f;
1864  if ((TYPreferenceManager::exists(TYDIRPREFERENCEMANAGER, "Luminosite")))
1865  {
1866  intensity = TYPreferenceManager::getDouble(TYDIRPREFERENCEMANAGER, "Luminosite");
1867  }
1868  else
1869  {
1870  TYPreferenceManager::setDouble(TYDIRPREFERENCEMANAGER, "Luminosite", intensity);
1871  }
1872 
1873  if (intensity < 0.1f)
1874  {
1875  intensity = 0.1f;
1876  }
1877  _pLightElement->setIntensity(intensity);
1878 
1879  // Mise a jour de la tolerance du picking.
1880  float precisPick = 3.0;
1881  if (TYPreferenceManager::exists(TYDIRPREFERENCEMANAGER, "PrecisPick"))
1882  {
1883  precisPick = TYPreferenceManager::getFloat(TYDIRPREFERENCEMANAGER, "PrecisPick");
1884  }
1885  else
1886  {
1887  TYPreferenceManager::setFloat(TYDIRPREFERENCEMANAGER, "PrecisPick", precisPick);
1888  }
1889  _pPickEditor->setPickTolerance(precisPick);
1890  _pPositionEditor->setPickPointPrecision(precisPick);
1891 
1892  // Mise a jour du pas de zoom de la mollette de la souris.
1893  float zoomStep = 1.0f;
1894  if (TYPreferenceManager::exists(TYDIRPREFERENCEMANAGER, "ZoomStep"))
1895  {
1896  zoomStep = TYPreferenceManager::getFloat(TYDIRPREFERENCEMANAGER, "ZoomStep");
1897  }
1898  else
1899  {
1900  TYPreferenceManager::setFloat(TYDIRPREFERENCEMANAGER, "ZoomStep", zoomStep);
1901  }
1902  _pCameraEditor->setWheelStep(zoomStep);
1903  _pDistanceEditor->setWheelStep(zoomStep);
1904  _pPositionEditor->setWheelStep(zoomStep);
1905 
1906  // Mise a jour du pas de l'angle du positionEditor
1907  float angle = 15.0;
1908  if (TYPreferenceManager::exists(TYDIRPREFERENCEMANAGER, "Angle"))
1909  {
1910  angle = TYPreferenceManager::getFloat(TYDIRPREFERENCEMANAGER, "Angle");
1911  }
1912  else
1913  {
1914  TYPreferenceManager::setFloat(TYDIRPREFERENCEMANAGER, "Angle", angle);
1915  }
1916 
1917  _pPositionEditor->setAngleStep(angle);
1918 
1919  // en 3D
1920  // bouton gauche
1921  int mouseLeftButtonFunct3D = 3;
1922  if (TYPreferenceManager::exists(TYDIRPREFERENCEMANAGER, "MouseLeftButtonFunct3D"))
1923  {
1924  mouseLeftButtonFunct3D =
1925  TYPreferenceManager::getInt(TYDIRPREFERENCEMANAGER, "MouseLeftButtonFunct3D");
1926  }
1927  else
1928  {
1929  TYPreferenceManager::setInt(TYDIRPREFERENCEMANAGER, "MouseLeftButtonFunct3D", mouseLeftButtonFunct3D);
1930  }
1931 
1932  switch (mouseLeftButtonFunct3D)
1933  {
1934  case 0:
1935  _pCameraEditor->setLeftButtonFunction3D(&TYCameraEditor::cameraZoom);
1936  break;
1937  case 1:
1938  _pCameraEditor->setLeftButtonFunction3D(&TYCameraEditor::cameraTranslate);
1939  break;
1940  case 2:
1941  _pCameraEditor->setLeftButtonFunction3D(&TYCameraEditor::cameraRoll);
1942  break;
1943  case 3:
1944  _pCameraEditor->setLeftButtonFunction3D(&TYCameraEditor::cameraRotate);
1945  break;
1946  }
1947 
1948  // bouton droit
1949  int mouseRightButtonFunct3D = 0;
1950  if (TYPreferenceManager::exists(TYDIRPREFERENCEMANAGER, "MouseRightButtonFunct3D"))
1951  {
1952  mouseRightButtonFunct3D =
1953  TYPreferenceManager::getInt(TYDIRPREFERENCEMANAGER, "MouseRightButtonFunct3D");
1954  }
1955  else
1956  {
1957  TYPreferenceManager::setInt(TYDIRPREFERENCEMANAGER, "MouseRightButtonFunct3D",
1958  mouseRightButtonFunct3D);
1959  }
1960 
1961  switch (mouseRightButtonFunct3D)
1962  {
1963  case 0:
1964  _pCameraEditor->setRightButtonFunction3D(&TYCameraEditor::cameraZoom);
1965  break;
1966  case 1:
1967  _pCameraEditor->setRightButtonFunction3D(&TYCameraEditor::cameraTranslate);
1968  break;
1969  case 2:
1970  _pCameraEditor->setRightButtonFunction3D(&TYCameraEditor::cameraRoll);
1971  break;
1972  case 3:
1973  _pCameraEditor->setRightButtonFunction3D(&TYCameraEditor::cameraRotate);
1974  break;
1975  }
1976 
1977  // bouton central
1978  int mouseMiddleButtonFunct3D = 2;
1979  if (TYPreferenceManager::exists(TYDIRPREFERENCEMANAGER, "MouseMiddleButtonFunct3D"))
1980  {
1981  mouseMiddleButtonFunct3D =
1982  TYPreferenceManager::getInt(TYDIRPREFERENCEMANAGER, "MouseMiddleButtonFunct3D");
1983  }
1984  else
1985  {
1986  TYPreferenceManager::setInt(TYDIRPREFERENCEMANAGER, "MouseMiddleButtonFunct3D",
1987  mouseMiddleButtonFunct3D);
1988  }
1989 
1990  switch (mouseMiddleButtonFunct3D)
1991  {
1992  case 0:
1993  _pCameraEditor->setMiddleButtonFunction3D(&TYCameraEditor::cameraZoom);
1994  break;
1995  case 1:
1996  _pCameraEditor->setMiddleButtonFunction3D(&TYCameraEditor::cameraTranslate);
1997  break;
1998  case 2:
1999  _pCameraEditor->setMiddleButtonFunction3D(&TYCameraEditor::cameraRoll);
2000  break;
2001  case 3:
2002  _pCameraEditor->setMiddleButtonFunction3D(&TYCameraEditor::cameraRotate);
2003  break;
2004  }
2005 
2006  // Mode shift.
2007  // 2D
2008  // bouton gauche
2009  int mouseShiftLeftButtonFunct2D = 1;
2010  if (TYPreferenceManager::exists(TYDIRPREFERENCEMANAGER, "MouseShiftLeftButtonFunct2D"))
2011  {
2012  mouseShiftLeftButtonFunct2D =
2013  TYPreferenceManager::getInt(TYDIRPREFERENCEMANAGER, "MouseShiftLeftButtonFunct2D");
2014  }
2015  else
2016  {
2017  TYPreferenceManager::setInt(TYDIRPREFERENCEMANAGER, "MouseShiftLeftButtonFunct2D",
2018  mouseShiftLeftButtonFunct2D);
2019  }
2020 
2021  switch (mouseShiftLeftButtonFunct2D)
2022  {
2023  case 0:
2024  _pCameraEditor->setShiftLeftButtonFunction2D(&TYCameraEditor::cameraZoom);
2025  break;
2026  case 1:
2027  _pCameraEditor->setShiftLeftButtonFunction2D(&TYCameraEditor::cameraTranslate);
2028  break;
2029  }
2030 
2031  // bouton droit
2032  int mouseShiftRightButtonFunct2D = 0;
2033  if (TYPreferenceManager::exists(TYDIRPREFERENCEMANAGER, "MouseShiftRightButtonFunct2D"))
2034  {
2035  mouseShiftRightButtonFunct2D =
2036  TYPreferenceManager::getInt(TYDIRPREFERENCEMANAGER, "MouseShiftRightButtonFunct2D");
2037  }
2038  else
2039  {
2040  TYPreferenceManager::setInt(TYDIRPREFERENCEMANAGER, "MouseShiftRightButtonFunct2D",
2041  mouseShiftRightButtonFunct2D);
2042  }
2043 
2044  switch (mouseShiftRightButtonFunct2D)
2045  {
2046  case 0:
2047  _pCameraEditor->setShiftRightButtonFunction2D(&TYCameraEditor::cameraZoom);
2048  break;
2049  case 1:
2050  _pCameraEditor->setShiftRightButtonFunction2D(&TYCameraEditor::cameraTranslate);
2051  break;
2052  }
2053 
2054  // en 3D
2055  // bouton gauche
2056  int mouseShiftLeftButtonFunct3D = 1;
2057  if (TYPreferenceManager::exists(TYDIRPREFERENCEMANAGER, "MouseShiftLeftButtonFunct3D"))
2058  {
2059  mouseShiftLeftButtonFunct3D =
2060  TYPreferenceManager::getInt(TYDIRPREFERENCEMANAGER, "MouseShiftLeftButtonFunct3D");
2061  }
2062  else
2063  {
2064  TYPreferenceManager::setInt(TYDIRPREFERENCEMANAGER, "MouseShiftLeftButtonFunct3D",
2065  mouseShiftLeftButtonFunct3D);
2066  }
2067 
2068  switch (mouseShiftLeftButtonFunct3D)
2069  {
2070  case 0:
2071  _pCameraEditor->setShiftLeftButtonFunction3D(&TYCameraEditor::cameraZoom);
2072  break;
2073  case 1:
2074  _pCameraEditor->setShiftLeftButtonFunction3D(&TYCameraEditor::cameraTranslate);
2075  break;
2076  case 2:
2077  _pCameraEditor->setShiftLeftButtonFunction3D(&TYCameraEditor::cameraRoll);
2078  break;
2079  case 3:
2080  _pCameraEditor->setShiftLeftButtonFunction3D(&TYCameraEditor::cameraRotate);
2081  break;
2082  }
2083 
2084  // bouton droit
2085  int mouseShiftRightButtonFunct3D = 2;
2086  if (TYPreferenceManager::exists(TYDIRPREFERENCEMANAGER, "MouseShiftRightButtonFunct3D"))
2087  {
2088  mouseShiftRightButtonFunct3D =
2089  TYPreferenceManager::getInt(TYDIRPREFERENCEMANAGER, "MouseShiftRightButtonFunct3D");
2090  }
2091  else
2092  {
2093  TYPreferenceManager::setInt(TYDIRPREFERENCEMANAGER, "MouseShiftRightButtonFunct3D",
2094  mouseShiftRightButtonFunct3D);
2095  }
2096 
2097  switch (mouseShiftRightButtonFunct3D)
2098  {
2099  case 0:
2100  _pCameraEditor->setShiftRightButtonFunction3D(&TYCameraEditor::cameraZoom);
2101  break;
2102  case 1:
2103  _pCameraEditor->setShiftRightButtonFunction3D(&TYCameraEditor::cameraTranslate);
2104  break;
2105  case 2:
2106  _pCameraEditor->setShiftRightButtonFunction3D(&TYCameraEditor::cameraRoll);
2107  break;
2108  case 3:
2109  _pCameraEditor->setShiftRightButtonFunction3D(&TYCameraEditor::cameraRotate);
2110  break;
2111  }
2112 
2113  // Force un update de la camera
2114  _pCameraEditor->setNavigationOnViewType(getCurrentView());
2115 
2116  // Update de l'editor courant
2117  // setEditorMode(_lastEditorMode); // DTn : Correction du bug #0009661
2118 
2119  // Mets a jour la structure graphique de l'element
2120  updateElementGraphic(true);
2121 
2122  // Refresh
2123  updateView(false);
2124 }
2125 
2126 void TYModelerFrame::startMovingRenderMode()
2127 {
2128  TYOpenGLRenderer::RenderMode currentMode = getRenderMode();
2129  // On passe en mode Wireframe si l'option est activee et qu'on est
2130  // pas deja dans ce mode
2131  if (_wireframeOnMovingCamera && (currentMode != TYOpenGLRenderer::Wireframe))
2132  {
2133  // On conserve le mode courant
2134  _lastRenderMode = currentMode;
2135  // On passe en Wireframe
2136  setRenderMode(TYOpenGLRenderer::Wireframe, false);
2137  }
2138 }
2139 
2140 void TYModelerFrame::stopMovingRenderMode()
2141 {
2142  if (_wireframeOnMovingCamera)
2143  {
2144  // On revient dans le mode courant
2145  setRenderMode(_lastRenderMode, true);
2146  }
2147 }
2148 
2149 void TYModelerFrame::updateScale()
2150 {
2151  if (_showScale)
2152  {
2153  QVector3D pt0 = _pView->getViewport().displayToWorld(QVector3D(0.0, 0.0, 0.1));
2154  QVector3D pt1 = _pView->getViewport().displayToWorld(QVector3D(200.0, 0.0, 0.1));
2155 
2156  double value = pt0.distanceToPoint(pt1);
2157 
2158  int i = floor(log10(value));
2159  int n = floor(value / pow(10, i));
2160  if (n == 3 || n == 4)
2161  {
2162  n = 5;
2163  }
2164  else if (n >= 6 && n <= 9)
2165  {
2166  n = 1;
2167  i++;
2168  }
2169  double distanceInRealWorld = n * pow(10, i);
2170  double distanceInDisplayWorld = 200.0 * distanceInRealWorld / value;
2171  QString max = QString().setNum(distanceInRealWorld, 'g', 3);
2172  QString mid = QString().setNum(distanceInRealWorld / 2, 'g', 3);
2173  _pOGLScalarBarElement->setTexts("0", mid.toStdString(), max.toStdString());
2174  _pOGLScalarBarElement->setSizes(distanceInDisplayWorld, 8);
2175  }
2176 }
2177 
2178 void TYModelerFrame::showScale(bool show)
2179 {
2180  _showScale = show;
2181 
2182  _pOGLScalarBarElement->setVisibility(_showScale);
2183 
2184  _pView->getRenderer()->invalidateScene();
2185  updateView(false, true);
2186 }
2187 
2188 double TYModelerFrame::getDouble(const QString& title, const QString& txt, double min, double max, double val,
2189  bool& ok, int dec)
2190 {
2191  QLocale loc = QLocale(QLocale::English);
2192  TYInputDialog dialog{};
2193  dialog.setLocale(loc); // Will use a dot
2194  dialog.setWindowTitle(title);
2195  dialog.setLabelText(txt);
2196  dialog.setDoubleRange(min, max);
2197  dialog.setTextValue(QString::number(val));
2198  dialog.setDoubleValue(val);
2199  dialog.setDoubleDecimals(dec);
2200  dialog.setInputMode(QInputDialog::TextInput);
2201  ok = dialog.exec();
2202  return dialog.doubleValue();
2203 }
3d.h
All base classes related to 3D manipulation.
PERSPECTIVE
@ PERSPECTIVE
Definition: OGLCamera.h:42
PARALLEL
@ PARALLEL
Definition: OGLCamera.h:41
FREE
@ FREE
Definition: OGLCamera.h:43
getColor
QColor getColor
Definition: OGLSimpleMaterial.cpp:18
TYAbstractSceneEditor.h
gestion de l'interaction entre la vue graphique (2D ou 3D) et le clavier et la souris (fichier header...
getTYApp
TYApplication * getTYApp()
Retourne le pointeur sur l'application.
Definition: TYApplication.cpp:46
TYApplication.h
pour l'application Tympan (fichier header)
TYCameraEditor.h
gestion de l'edition de la camera (fichier header)
min
#define min(a, b)
Definition: TYCameraZoneEditor.cpp:42
TYCameraZoneEditor.h
gestion de zoom par zone selectionnee (fichier obsolete)(fichier header)
TYDistanceEditor.h
outil de mesure des distances (fichier header)
TYElementPicker.h
gestion des elements selectionnes par picking (fichier header)
TYDIRPREFERENCEMANAGER
#define TYDIRPREFERENCEMANAGER
Definition: TYElement.h:51
TYInputDialog.h
outil IHM pour une entrée utilisateur (fichier header)
IMG
#define IMG(id)
Definition: TYModelerFrame.cpp:92
getBoundingBox
OBox getBoundingBox(TYElement *pElement)
Definition: TYModelerFrame.cpp:1194
TR
#define TR(id)
Definition: TYModelerFrame.cpp:91
TYModelerFrame.h
Classe generique pour une fenetre de modeleur (fichier header)
TYOpenGLRenderer.h
Realise le rendu VTK et le rendu OpenGL (fichier header)
TYPickEditor.h
gestion de l'element actionne par picking (fichier header)
TYPositionEditor.h
gestion de la position selon les modes 'moving', 'rotation', 'edition' (fichier header)
TYPrintDialog.h
Boite de dialogue des parametres d'impression (fichier header)
name
const char * name
Definition: TYRouteWidget.cpp:33
TYSetCameraCoordinates.h
Repositionnement de la camera en fonction de coordonnees specifiees (fichier header)
TYSourceLineicGraphic.h
Representation graphique d'une source lineique (fichier header)
TYSourceSurfacicGraphic.h
Representation graphique d'une surface de source (fichier header)
OBox
The box class.
Definition: 3d.h:1346
OBox::_min
OPoint3D _min
Minimal coordinates of the OBox.
Definition: 3d.h:1423
OBox::_max
OPoint3D _max
Maximal coordinates of the OBox.
Definition: 3d.h:1424
OColor
Definition: color.h:31
OColor::b
float b
Definition: color.h:33
OColor::r
float r
Definition: color.h:33
OColor::g
float g
Definition: color.h:33
OCoord3D::_y
double _y
y coordinate of OCoord3D
Definition: 3d.h:283
OCoord3D::_z
double _z
z coordinate of OCoord3D
Definition: 3d.h:284
OCoord3D::_x
double _x
x coordinate of OCoord3D
Definition: 3d.h:282
OGLCamera::setFromToUp
void setFromToUp(const QVector3D &_from, const QVector3D &_to, const QVector3D &_up)
Definition: OGLCamera.cpp:296
OGLCamera::getTranslation
void getTranslation(double &x, double &y, double &z)
Definition: OGLCamera.cpp:474
OGLCamera::resetZoom
void resetZoom(int w=-1, int h=-1)
Definition: OGLCamera.cpp:417
OGLCamera::resetRotations
void resetRotations()
Definition: OGLCamera.cpp:458
OGLCamera::setTranslation
void setTranslation(double x, double y, double z)
Definition: OGLCamera.cpp:467
OGLCamera::cameraType
CameraType cameraType() const
Definition: OGLCamera.cpp:92
OGLCamera::setSize
void setSize(int w, int h)
Definition: OGLCamera.cpp:78
OGLCamera::setDistanceStep
void setDistanceStep(NxReal _magnitudeStepUp, NxReal _magnitudeStepFront, NxReal _magnitudeStepLeft)
Definition: OGLCamera.cpp:237
OGLElement::getVisibility
bool getVisibility()
Definition: OGLElement.h:55
OGLElement::setVisibility
void setVisibility(bool bVisible)
Definition: OGLElement.h:51
OGLElement::setIs3D
void setIs3D(bool bIs3D)
Definition: OGLElement.h:59
OGLElement::setDisplayPosition
void setDisplayPosition(double displayPositionX, double displayPositionY)
Definition: OGLElement.h:46
OGLGridElement::getShowGridXZ
bool getShowGridXZ()
Definition: OGLGridElement.h:83
OGLGridElement::getShowGridZY
bool getShowGridZY()
Definition: OGLGridElement.h:87
OGLGridElement::setShowGridXZ
void setShowGridXZ(bool bShow)
Definition: OGLGridElement.h:70
OGLGridElement::setGridDimX
void setGridDimX(const float gridDimX)
Definition: OGLGridElement.h:53
OGLGridElement::setShowGridXY
void setShowGridXY(bool bShow)
Definition: OGLGridElement.h:66
OGLGridElement::getShowGridXY
bool getShowGridXY()
Definition: OGLGridElement.h:79
OGLGridElement::setGridDimY
void setGridDimY(const float gridDimY)
Definition: OGLGridElement.h:57
OGLGridElement::setColor
void setColor(const OColor &oColor)
Definition: OGLGridElement.cpp:50
OGLGridElement::setShowGridZY
void setShowGridZY(bool bShow)
Definition: OGLGridElement.h:74
OGLGridElement::setGridStep
void setGridStep(const float gridStep)
Definition: OGLGridElement.h:61
OGLLightElement::setIntensity
void setIntensity(const float intensity)
Definition: OGLLightElement.h:56
OGLLightElement::init
void init(int index, OPoint3D position, float intensity)
Definition: OGLLightElement.cpp:47
OGLLineElement::setPoint2
void setPoint2(const QVector3D &point2)
Definition: OGLLineElement.h:58
OGLLineElement::setColor
void setColor(const OColor &oColor)
Definition: OGLLineElement.cpp:49
OGLLineElement::setLineWidth
void setLineWidth(float lineWidth)
Definition: OGLLineElement.h:63
OGLLineElement::setPoint1
void setPoint1(const QVector3D &point1)
Definition: OGLLineElement.h:54
OGLScalarBarElement::setSizes
void setSizes(float width, float height)
Definition: OGLScalarBarElement.h:73
OGLScalarBarElement::setTexts
void setTexts(const std::string &text0, const std::string &text1, const std::string &text2)
Definition: OGLScalarBarElement.h:67
OGLScalarBarElement::setFontColor
void setFontColor(const OColor &oFontColor)
Definition: OGLScalarBarElement.h:58
OGLScalarBarElement::setFont
void setFont(const QString &qsFontPath)
Definition: OGLScalarBarElement.h:54
OGLScalarBarElement::setPosition
void setPosition(const QVector3D &position)
Definition: OGLScalarBarElement.h:63
OGLTextElement::setColor
void setColor(const OColor &oColor)
Definition: OGLTextElement.cpp:48
OGLTextElement::setTextToDisplay
void setTextToDisplay(const QString &qsText)
Definition: OGLTextElement.cpp:38
OGLTextElement::setFont
void setFont(const QString &qsFontPath)
Definition: OGLTextElement.cpp:43
OPoint3D
The 3D point class.
Definition: 3d.h:487
OPrototype::getClassName
virtual const char * getClassName() const
Definition: TYElement.h:248
SmartPtr::_pObj
T * _pObj
The real pointer, must derived IRefCount.
Definition: smartptr.h:307
TYAbstractSceneEditor::setWheelStep
void setWheelStep(float step=1.0)
Met Ã&#160; jour le pas de zoom de la caméra.
Definition: TYAbstractSceneEditor.cpp:191
TYAbstractSceneEditor::close
virtual void close()
Appeler apres l'utilisation de l'editor.
Definition: TYAbstractSceneEditor.h:132
TYAbstractSceneEditor::snapToGrid
static void snapToGrid(float &x, float &y, float &z, float &gridMagnStep)
Methode utilitaire qui adapte les coordonnees d'un point pour que celui-ci soit aligne avec la grille...
Definition: TYAbstractSceneEditor.cpp:172
TYAbstractSceneEditor::disconnect
virtual void disconnect()
Deconnecte cet editor a l'interactor associe.
Definition: TYAbstractSceneEditor.cpp:117
TYAbstractSceneEditor::init
virtual void init()
Appeler avant l'utilisation de l'editor.
Definition: TYAbstractSceneEditor.h:122
TYAbstractSceneEditor::connect
virtual void connect()
Connecte cet editor a l'interactor associe.
Definition: TYAbstractSceneEditor.cpp:73
TYActionManager::getHistorySize
int getHistorySize()
Retourne la taille de l'historique.
Definition: TYActionManager.h:85
TYActionManager::setHistorySize
void setHistorySize(int size)
Definit la taille de l'historique.
Definition: TYActionManager.cpp:168
TYApplication::getCurProjet
LPTYProjet getCurProjet()
Set/Get du projet courant.
Definition: TYApplication.h:108
TYApplication::getCalculManager
TYCalculManager * getCalculManager()
Get du gestionnaire de calculs.
Definition: TYApplication.h:99
TYCalculManager::askForResetResultat
bool askForResetResultat()
Previent l'utilisateur que le resultat va etre efface, si celui-ci est valide.
Definition: TYCalculManager.cpp:283
TYCalcul::getDateModif
QString getDateModif() const
Get modification date.
Definition: TYCalcul.h:199
TYCalcul::isInSelection
bool isInSelection(TYUUID id)
Tests if the element is present in the selection of this Calculation.
Definition: TYCalcul.cpp:1004
TYCalcul::getDateCreation
QString getDateCreation() const
Set/Get of creation date.
Definition: TYCalcul.h:185
TYCalcul::getComment
QString getComment() const
Get comments.
Definition: TYCalcul.h:218
TYCameraEditor
Gestion de l'edition en mode camera.
Definition: TYCameraEditor.h:42
TYCameraEditor::setMiddleButtonFunction3D
void setMiddleButtonFunction3D(void(TYCameraEditor::*function)())
Definition: TYCameraEditor.cpp:272
TYCameraEditor::setRightButtonFunction3D
void setRightButtonFunction3D(void(TYCameraEditor::*function)())
Definition: TYCameraEditor.cpp:284
TYCameraEditor::setShiftRightButtonFunction3D
void setShiftRightButtonFunction3D(void(TYCameraEditor::*function)())
Definition: TYCameraEditor.cpp:308
TYCameraEditor::setNavigationOnViewType
void setNavigationOnViewType(int view)
Switch auto entre navi 2D ou 3D.
Definition: TYCameraEditor.cpp:694
TYCameraEditor::setShiftRightButtonFunction2D
void setShiftRightButtonFunction2D(void(TYCameraEditor::*function)())
Definition: TYCameraEditor.cpp:248
TYCameraEditor::setLeftButtonFunction3D
void setLeftButtonFunction3D(void(TYCameraEditor::*function)())
Definition: TYCameraEditor.cpp:260
TYCameraEditor::setShiftLeftButtonFunction2D
void setShiftLeftButtonFunction2D(void(TYCameraEditor::*function)())
Definition: TYCameraEditor.cpp:236
TYCameraEditor::stopCameraZoom
void stopCameraZoom()
Force l'arrêt du mode zoom de la caméra.
Definition: TYCameraEditor.cpp:380
TYCameraEditor::setShiftLeftButtonFunction3D
void setShiftLeftButtonFunction3D(void(TYCameraEditor::*function)())
Definition: TYCameraEditor.cpp:296
TYCameraEditor::setWheelStep
void setWheelStep(float step)
Definition: TYCameraEditor.h:91
TYCameraZoneEditor
gestion de zoom par zone selectionnee (obsolete)
Definition: TYCameraZoneEditor.h:37
TYDistanceEditor
outil de mesure des distances
Definition: TYDistanceEditor.h:40
TYElementGraphic::_gDrawNormals
static bool _gDrawNormals
Indique si les normals doivent etre visible.
Definition: TYElementGraphic.h:241
TYElementGraphic::boundingBox
OBox boundingBox() const
Definition: TYElementGraphic.cpp:227
TYElementGraphic::_gDrawPlafond
static bool _gDrawPlafond
Indique si les plafonds doivent etre visible.
Definition: TYElementGraphic.h:244
TYElementPicker
gestion des elements selectionnes par picking
Definition: TYElementPicker.h:42
TYElement::getParent
TYElement * getParent() const
Definition: TYElement.h:706
TYElement::getName
virtual QString getName() const
Definition: TYElement.h:691
TYMachine::getModele
QString getModele() const
Definition: TYMachine.h:124
TYMachine::getCommentaire
QString getCommentaire() const
Definition: TYMachine.h:139
TYMachine::getCategorie
int getCategorie() const
Definition: TYMachine.h:94
TYMachine::getConstructeur
QString getConstructeur() const
Definition: TYMachine.h:109
TYModelerFrame::wheelEvent
virtual void wheelEvent(QWheelEvent *pEvent)
Definition: TYModelerFrame.cpp:1662
TYModelerFrame::_pSnapGridBtn
QToolButton * _pSnapGridBtn
Button to activate the magnetic grid.
Definition: TYModelerFrame.h:542
TYModelerFrame::setSnapGridActive
void setSnapGridActive(bool state)
Definition: TYModelerFrame.cpp:920
TYModelerFrame::closeEvent
virtual void closeEvent(QCloseEvent *pEvent)
Definition: TYModelerFrame.cpp:1690
TYModelerFrame::updateElementGraphic
void updateElementGraphic(bool force=false)
Definition: TYModelerFrame.cpp:1761
TYModelerFrame::leaveEvent
virtual void leaveEvent(QEvent *pEvent)
Definition: TYModelerFrame.cpp:1709
TYModelerFrame::_curViewType
int _curViewType
The type of the current view.
Definition: TYModelerFrame.h:647
TYModelerFrame::_pStatusBar
QStatusBar * _pStatusBar
Status bar.
Definition: TYModelerFrame.h:572
TYModelerFrame::computeCurPos
virtual bool computeCurPos(int x, int y, float *pos)
Definition: TYModelerFrame.cpp:1608
TYModelerFrame::_pCameraEditor
TYCameraEditor * _pCameraEditor
Manages the camera.
Definition: TYModelerFrame.h:532
TYModelerFrame::showScale
void showScale(bool show)
Definition: TYModelerFrame.cpp:2178
TYModelerFrame::_editorModeAccepted
bool _editorModeAccepted
Indicates if the editing mode has been processed.
Definition: TYModelerFrame.h:650
TYModelerFrame::_pOGLScalarBarElement
OGLScalarBarElement * _pOGLScalarBarElement
Graphic object for representing the scale.
Definition: TYModelerFrame.h:626
TYModelerFrame::_pShowRaysBtn
QToolButton * _pShowRaysBtn
Button for displaying rays calculated by ray tracing.
Definition: TYModelerFrame.h:566
TYModelerFrame::setRenderModeSlot
virtual void setRenderModeSlot(int mode)
Definition: TYModelerFrame.cpp:696
TYModelerFrame::_pElement
LPTYElement _pElement
A pointer to the element to edit.
Definition: TYModelerFrame.h:680
TYModelerFrame::showPlafond
void showPlafond(bool show)
Definition: TYModelerFrame.cpp:892
TYModelerFrame::_pShowScale
QToolButton * _pShowScale
Button for displaying the scale.
Definition: TYModelerFrame.h:629
TYModelerFrame::enterEvent
virtual void enterEvent(QEvent *pEvent)
Definition: TYModelerFrame.cpp:1700
TYModelerFrame::_pPositionEditor
TYPositionEditor * _pPositionEditor
Editor for moving elements.
Definition: TYModelerFrame.h:590
TYModelerFrame::setEditorModeToCamera
void setEditorModeToCamera()
Definition: TYModelerFrame.h:310
TYModelerFrame::_pCameraZoneEditor
TYCameraZoneEditor * _pCameraZoneEditor
Editor to define a zoom area for the camera.
Definition: TYModelerFrame.h:593
TYModelerFrame::_pOGLTextElement
OGLTextElement * _pOGLTextElement
2D label to display the type of view.
Definition: TYModelerFrame.h:596
TYModelerFrame::resizeEvent
virtual void resizeEvent(QResizeEvent *pEvent)
Definition: TYModelerFrame.cpp:1668
TYModelerFrame::_pCurrentEditor
TYAbstractSceneEditor * _pCurrentEditor
The current editor.
Definition: TYModelerFrame.h:653
TYModelerFrame::setKeepRays
void setKeepRays(bool keepRays)
Definition: TYModelerFrame.cpp:859
TYModelerFrame::~TYModelerFrame
virtual ~TYModelerFrame()
Definition: TYModelerFrame.cpp:481
TYModelerFrame::editorModeChanged
void editorModeChanged(int mode)
TYModelerFrame::_pOGLLineElementAxeX
OGLLineElement * _pOGLLineElementAxeX
Geometry of the Axes.
Definition: TYModelerFrame.h:599
TYModelerFrame::setGridLinesActorsVisibility
void setGridLinesActorsVisibility(bool showGridXY, bool showGridXZ, bool showGridZY)
Definition: TYModelerFrame.cpp:1653
TYModelerFrame::_pShowPlafondBtn
QToolButton * _pShowPlafondBtn
Button for displaying the ceiling of buildings.
Definition: TYModelerFrame.h:560
TYModelerFrame::showRays
void showRays(bool show)
Definition: TYModelerFrame.cpp:832
TYModelerFrame::viewTypeChanged
void viewTypeChanged(int)
TYModelerFrame::_wireframeOnMovingCamera
bool _wireframeOnMovingCamera
Indicates whether to switch to wireframe rendering during camera movement.
Definition: TYModelerFrame.h:575
TYModelerFrame::_pShowNormalsBtn
QToolButton * _pShowNormalsBtn
Button for displaying normals.
Definition: TYModelerFrame.h:554
TYModelerFrame::focusInEvent
virtual void focusInEvent(QFocusEvent *pEvent)
Definition: TYModelerFrame.cpp:1675
TYModelerFrame::_snapGridActive
bool _snapGridActive
Indicates whether or not to activate the magnetic grid.
Definition: TYModelerFrame.h:545
TYModelerFrame::setWireframeOnMovingCamera
void setWireframeOnMovingCamera(bool state)
Definition: TYModelerFrame.h:439
TYModelerFrame::_actionManager
TYActionManager _actionManager
For managing the history.
Definition: TYModelerFrame.h:617
TYModelerFrame::aboutToClose
void aboutToClose()
TYModelerFrame::_pLightElement
OGLLightElement * _pLightElement
The default light.
Definition: TYModelerFrame.h:620
TYModelerFrame::getSnapGridActive
bool getSnapGridActive()
Definition: TYModelerFrame.h:191
TYModelerFrame::_pCtrlLayout
QBoxLayout * _pCtrlLayout
The layout where buttons, etc., are located.
Definition: TYModelerFrame.h:638
TYModelerFrame::mouseMoveEvent
virtual void mouseMoveEvent(QMouseEvent *pEvent)
Definition: TYModelerFrame.cpp:1565
TYModelerFrame::_pLayout
QGridLayout * _pLayout
The layout of this frame.
Definition: TYModelerFrame.h:536
TYModelerFrame::_pShowSourcesBtn
QToolButton * _pShowSourcesBtn
Button for displaying point sources.
Definition: TYModelerFrame.h:548
TYModelerFrame::_pOGLTextElementLabelY
OGLTextElement * _pOGLTextElementLabelY
Definition: TYModelerFrame.h:603
TYModelerFrame::setViewType
virtual void setViewType(int view)
Definition: TYModelerFrame.cpp:607
TYModelerFrame::_pOGLLineElementX
OGLLineElement * _pOGLLineElementX
X and Y axes of the grid.
Definition: TYModelerFrame.h:610
TYModelerFrame::statusBar
QStatusBar * statusBar()
Definition: TYModelerFrame.h:183
TYModelerFrame::_pGridBtn
QToolButton * _pGridBtn
Button to activate the grid.
Definition: TYModelerFrame.h:607
TYModelerFrame::isElementInCurrentProjet
bool isElementInCurrentProjet()
Definition: TYModelerFrame.cpp:570
TYModelerFrame::_pOGLGridElement
OGLGridElement * _pOGLGridElement
Definition: TYModelerFrame.h:623
TYModelerFrame::_pView
TYRenderWindowInteractor * _pView
The graphics window.
Definition: TYModelerFrame.h:644
TYModelerFrame::frameResized
void frameResized()
TYModelerFrame::_pCopyBtn
QToolButton * _pCopyBtn
Button for taking a screenshot.
Definition: TYModelerFrame.h:677
TYModelerFrame::close
virtual bool close()
Definition: TYModelerFrame.cpp:552
TYModelerFrame::getDefaultZCoord
virtual float getDefaultZCoord()
Returns default Z coordinate for editors This value will depend on the type of modeler and of the fix...
Definition: TYModelerFrame.cpp:1648
TYModelerFrame::_showPlafond
bool _showPlafond
Indicates whether or not to display or hide the ceiling of buildings.
Definition: TYModelerFrame.h:563
TYModelerFrame::showNormals
void showNormals(bool show)
Definition: TYModelerFrame.cpp:864
TYModelerFrame::_pOGLLineElementAxeZ
OGLLineElement * _pOGLLineElementAxeZ
Definition: TYModelerFrame.h:601
TYModelerFrame::_pRenderModeBox
QComboBox * _pRenderModeBox
Combo box for rendering mode.
Definition: TYModelerFrame.h:539
TYModelerFrame::_pOGLTextElementLabelX
OGLTextElement * _pOGLTextElementLabelX
Definition: TYModelerFrame.h:602
TYModelerFrame::getRenderMode
TYOpenGLRenderer::RenderMode getRenderMode()
Definition: TYModelerFrame.h:142
TYModelerFrame::_showGrid
bool _showGrid
Indicates whether to display the grid or not.
Definition: TYModelerFrame.h:614
TYModelerFrame::TYModelerFrame
TYModelerFrame(QWidget *parent=0, const char *name=0, Qt::WindowFlags f=Qt::SubWindow)
Definition: TYModelerFrame.cpp:101
TYModelerFrame::_showNormals
bool _showNormals
Indicates whether or not to display or hide normals.
Definition: TYModelerFrame.h:557
TYModelerFrame::setCameraCoordinates
void setCameraCoordinates()
Definition: TYModelerFrame.cpp:926
TYModelerFrame::_pOGLTextElementLabelZ
OGLTextElement * _pOGLTextElementLabelZ
Definition: TYModelerFrame.h:604
TYModelerFrame::isElementInCurrentCalcul
bool isElementInCurrentCalcul()
Definition: TYModelerFrame.cpp:557
TYModelerFrame::askForResetResultat
bool askForResetResultat()
Definition: TYModelerFrame.cpp:595
TYModelerFrame::_showScale
bool _showScale
Indicates whether to display the scale or not.
Definition: TYModelerFrame.h:632
TYModelerFrame::eltModified
void eltModified(LPTYElement pElt)
TYModelerFrame::_lastEditorMode
int _lastEditorMode
To keep track of the last editing mode.
Definition: TYModelerFrame.h:581
TYModelerFrame::_pSetCameraCoordinatesBtn
QToolButton * _pSetCameraCoordinatesBtn
Button to specify camera coordinates.
Definition: TYModelerFrame.h:671
TYModelerFrame::_lastRenderMode
TYOpenGLRenderer::RenderMode _lastRenderMode
The last current rendering mode.
Definition: TYModelerFrame.h:578
TYModelerFrame::_pOGLLineElementAxeY
OGLLineElement * _pOGLLineElementAxeY
Definition: TYModelerFrame.h:600
TYModelerFrame::updateCurPosInfo
void updateCurPosInfo(int x, int y)
Definition: TYModelerFrame.cpp:1567
TYModelerFrame::_gridDimX
float _gridDimX
Grid dimension in X.
Definition: TYModelerFrame.h:666
TYModelerFrame::_gridDimY
float _gridDimY
Grid dimension in Y.
Definition: TYModelerFrame.h:668
TYModelerFrame::startMovingRenderMode
void startMovingRenderMode()
Definition: TYModelerFrame.cpp:2126
TYModelerFrame::_pPicker
TYElementPicker * _pPicker
For picking.
Definition: TYModelerFrame.h:584
TYModelerFrame::setRenderMode
virtual void setRenderMode(TYOpenGLRenderer::RenderMode mode, bool bUpdateGL)
Definition: TYModelerFrame.cpp:701
TYModelerFrame::_pOGLCameras
OGLCamera * _pOGLCameras[NbOfViews]
Cameras for each type of view.
Definition: TYModelerFrame.h:659
TYModelerFrame::_gridStep
float _gridStep
Grid step.
Definition: TYModelerFrame.h:662
TYModelerFrame::updatePreferences
virtual void updatePreferences()
Definition: TYModelerFrame.cpp:1779
TYModelerFrame::_showRays
bool _showRays
Indicates whether or not to display rays.
Definition: TYModelerFrame.h:569
TYModelerFrame::_pPickEditor
TYPickEditor * _pPickEditor
Manages the context menu.
Definition: TYModelerFrame.h:656
TYModelerFrame::_pOGLLineElementY
OGLLineElement * _pOGLLineElementY
Definition: TYModelerFrame.h:611
TYModelerFrame::_gridMagnStep
float _gridMagnStep
Magnetic grid step.
Definition: TYModelerFrame.h:664
TYModelerFrame::_pScreenShotBtn
QToolButton * _pScreenShotBtn
Button for saving a screenshot.
Definition: TYModelerFrame.h:674
TYModelerFrame::getPickEditor
TYPickEditor * getPickEditor()
Definition: TYModelerFrame.h:159
TYModelerFrame::keyPressEvent
virtual void keyPressEvent(QKeyEvent *pEvent)
Definition: TYModelerFrame.cpp:1491
TYModelerFrame::_pDistanceEditor
TYDistanceEditor * _pDistanceEditor
Tools for measuring.
Definition: TYModelerFrame.h:587
TYModelerFrame::setEditorMode
virtual void setEditorMode(int mode)
Definition: TYModelerFrame.cpp:718
TYModelerFrame::showGrid
void showGrid(bool show)
Definition: TYModelerFrame.cpp:788
TYModelerFrame::updateView
virtual void updateView(bool clipping=true, bool axesAndGrid=true)
Definition: TYModelerFrame.cpp:1348
TYModelerFrame::showEvent
virtual void showEvent(QShowEvent *pEvent)
Definition: TYModelerFrame.cpp:1680
TYModelerFrame::keyReleaseEvent
virtual void keyReleaseEvent(QKeyEvent *pEvent)
Definition: TYModelerFrame.cpp:1553
TYModelerFrame::getDouble
static double getDouble(const QString &title, const QString &txt, double min, double max, double val, bool &ok, int dec=2)
Definition: TYModelerFrame.cpp:2188
TYModelerFrame::_defaultZCoord
float _defaultZCoord
Default Z coordinate for editors.
Definition: TYModelerFrame.h:683
TYModelerFrame::getRenderer
TYOpenGLRenderer * getRenderer()
Definition: TYModelerFrame.h:126
TYModelerFrame::_showSources
bool _showSources
Indicates whether or not to display point sources.
Definition: TYModelerFrame.h:551
TYModelerFrame::_pViewTypeBox
QComboBox * _pViewTypeBox
Combo box for selecting the current camera.
Definition: TYModelerFrame.h:641
TYOpenGLRenderer::addLight
void addLight(OGLLightElement *pOGLElementLight)
Definition: TYOpenGLRenderer.cpp:398
TYOpenGLRenderer::addOGLElement
void addOGLElement(OGLElement *pOGLElement)
Definition: TYOpenGLRenderer.cpp:381
TYOpenGLRenderer::invalidateScene
void invalidateScene(void)
Definition: TYOpenGLRenderer.cpp:208
TYOpenGLRenderer::removeOGLElement
void removeOGLElement(OGLElement *pOGLElement)
Definition: TYOpenGLRenderer.cpp:413
TYOpenGLRenderer::setBackground
void setBackground(double *bgColor)
Definition: TYOpenGLRenderer.h:139
TYOpenGLRenderer::setRenderMode
void setRenderMode(RenderMode mode)
Definition: TYOpenGLRenderer.cpp:172
TYPickEditor
gestion de l'element actionne par picking
Definition: TYPickEditor.h:40
TYPickEditor::usePopup
void usePopup(bool state)
Definition: TYPickEditor.h:104
TYPickEditor::setPickTolerance
void setPickTolerance(float tolerance)
Definition: TYPickEditor.h:59
TYPickEditor::useHighlight
void useHighlight(bool state)
Definition: TYPickEditor.h:97
TYPositionEditor
gestion de la position selon les modes 'moving', 'rotation', 'edition'
Definition: TYPositionEditor.h:43
TYPositionEditor::setMode
void setMode(int mode)
Definition: TYPositionEditor.h:92
TYPositionEditor::setPickPointPrecision
void setPickPointPrecision(float precision)
Definition: TYPositionEditor.h:122
TYPositionEditor::setAngleStep
void setAngleStep(float step)
Definition: TYPositionEditor.h:107
TYPrintDialog
classe pour une boite de dialogue des parametres d'impression.
Definition: TYPrintDialog.h:51
TYPrintDialog::_groupBoxSite
QGroupBox * _groupBoxSite
Definition: TYPrintDialog.h:80
TYPrintDialog::_checkBoxCatMachine
QCheckBox * _checkBoxCatMachine
Definition: TYPrintDialog.h:73
TYPrintDialog::_checkBoxDateProjet
QCheckBox * _checkBoxDateProjet
Definition: TYPrintDialog.h:64
TYPrintDialog::_checkBoxNomProjet
QCheckBox * _checkBoxNomProjet
Definition: TYPrintDialog.h:65
TYPrintDialog::_checkBoxNomBatiment
QCheckBox * _checkBoxNomBatiment
Definition: TYPrintDialog.h:77
TYPrintDialog::_checkBoxNomSite
QCheckBox * _checkBoxNomSite
Definition: TYPrintDialog.h:75
TYPrintDialog::_checkBoxDateCalcul
QCheckBox * _checkBoxDateCalcul
Definition: TYPrintDialog.h:68
TYPrintDialog::_checkBoxCommentCalcul
QCheckBox * _checkBoxCommentCalcul
Definition: TYPrintDialog.h:67
TYPrintDialog::_groupBoxMachine
QGroupBox * _groupBoxMachine
Definition: TYPrintDialog.h:78
TYPrintDialog::_checkBoxNomCalcul
QCheckBox * _checkBoxNomCalcul
Definition: TYPrintDialog.h:69
TYPrintDialog::_groupBoxCalcul
QGroupBox * _groupBoxCalcul
Definition: TYPrintDialog.h:66
TYPrintDialog::_lineEditPied
QLineEdit * _lineEditPied
Definition: TYPrintDialog.h:83
TYPrintDialog::_lineEditTete
QLineEdit * _lineEditTete
Definition: TYPrintDialog.h:84
TYPrintDialog::_checkBoxCommentProjet
QCheckBox * _checkBoxCommentProjet
Definition: TYPrintDialog.h:62
TYPrintDialog::_checkBoxNomMachine
QCheckBox * _checkBoxNomMachine
Definition: TYPrintDialog.h:72
TYPrintDialog::_checkBoxModelMachine
QCheckBox * _checkBoxModelMachine
Definition: TYPrintDialog.h:74
TYPrintDialog::_groupBoxProjet
QGroupBox * _groupBoxProjet
Definition: TYPrintDialog.h:61
TYPrintDialog::_groupBoxBatiment
QGroupBox * _groupBoxBatiment
Definition: TYPrintDialog.h:79
TYPrintDialog::_lineEditTitre
QLineEdit * _lineEditTitre
Definition: TYPrintDialog.h:86
TYPrintDialog::_checkBoxAuteurProjet
QCheckBox * _checkBoxAuteurProjet
Definition: TYPrintDialog.h:63
TYPrintDialog::_checkBoxConstrMachine
QCheckBox * _checkBoxConstrMachine
Definition: TYPrintDialog.h:71
TYProjet
classe de definition d'un projet.
Definition: TYProjet.h:45
TYProjet::getDateModif
QString getDateModif() const
Get de la date de modification.
Definition: TYProjet.h:131
TYProjet::getAuteur
QString getAuteur() const
Get du nom de l'auteur.
Definition: TYProjet.h:93
TYProjet::getComment
QString getComment() const
Get des commentaires.
Definition: TYProjet.h:150
TYProjet::getDateCreation
QString getDateCreation() const
Get de la date de creation.
Definition: TYProjet.h:112
TYProjet::getSite
LPTYSiteNode getSite()
Get du site.
Definition: TYProjet.h:169
TYProjet::getCurrentCalcul
LPTYCalcul getCurrentCalcul()
Set/Get du pointeur du Calcul courant.
Definition: TYProjet.h:426
TYRayGraphic::_gVisible
static bool _gVisible
Indique si toutes les instances sont visibles.
Definition: TYRayGraphic.h:75
TYRenderViewport::worldToDisplay
QVector3D worldToDisplay(const QVector3D &world) const
Definition: TYRenderViewport.cpp:32
TYRenderViewport::displayToWorld
QVector3D displayToWorld(const QVector3D &display) const
Definition: TYRenderViewport.cpp:25
TYRenderWindowInteractor
Le role de cette classe est limite a emettre des signaux pouvant etre utilise pour interagir sur le r...
Definition: TYRenderWindowInteractor.h:43
TYRenderWindowInteractor::mouseMoved
void mouseMoved(int x, int y, Qt::MouseButtons button, Qt::KeyboardModifiers state)
TYRenderWindow::setActiveCamera
void setActiveCamera(OGLCamera *pCamera)
Definition: TYRenderWindow.h:77
TYRenderWindow::getViewport
const TYRenderViewport & getViewport() const
Definition: TYRenderWindow.cpp:170
TYRenderWindow::showInfos
void showInfos(bool state)
Definition: TYRenderWindow.cpp:106
TYRenderWindow::getRenderer
TYOpenGLRenderer * getRenderer()
Definition: TYRenderWindow.cpp:101
TYRenderWindow::getActiveCamera
OGLCamera * getActiveCamera()
Definition: TYRenderWindow.h:83
TYSetCameraCoordinates
Repositionnement de la camera en fonction de coordonnees specifiees.
Definition: TYSetCameraCoordinates.h:38
TYSourceLineicGraphic::_gVisible
static bool _gVisible
Indique si toutes les instances sont visibles.
Definition: TYSourceLineicGraphic.h:84
TYSourceSurfacicGraphic::_gVisible
static bool _gVisible
Indique si toutes les instances sont visibles.
Definition: TYSourceSurfacicGraphic.h:93
Generated on Wed May 13 2026 12:41:17 for Code_TYMPAN by doxygen 1.9.1