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  // _pCtrlLayout->addWidget(_pScreenShotBtn, 0);
239 
240  // Btn Copy
241  _pCopyBtn = new QToolButton(this);
242  _pCopyBtn->setIcon(QPixmap(IMG("id_icon_copy_btn")));
243  _pCopyBtn->setText(TR("id_copy_btn"));
244  _pCopyBtn->setToolTip(TR("id_copy_btn"));
245  _pCopyBtn->setFixedSize(24, 24);
246  connect(_pCopyBtn, &QToolButton::clicked, this, &TYModelerFrame::copy);
247  //_pCtrlLayout->addWidget(_pCopyBtn, 0);
248 
249  // _pCtrlLayout->addSpacing(7);
250 
251  // Btn Show Sources
252  _pShowSourcesBtn = new QToolButton(this);
253  _pShowSourcesBtn->setIcon(QPixmap(IMG("id_icon_source")));
254  _pShowSourcesBtn->setText(TR("id_show_source_btn"));
255  _pShowSourcesBtn->setToolTip(TR("id_show_source_btn"));
256  _pShowSourcesBtn->setCheckable(true);
257  _pShowSourcesBtn->setChecked(false);
258  _pShowSourcesBtn->setFixedSize(24, 24);
259  _pCtrlLayout->addWidget(_pShowSourcesBtn, 0);
260  connect(_pShowSourcesBtn, &QToolButton::toggled, this, &TYModelerFrame::showSources);
261  showSources();
262 
263  // Btn Show Normals
264  _pShowNormalsBtn = new QToolButton(this);
265  _pShowNormalsBtn->setIcon(QPixmap(IMG("id_icon_normals")));
266  _pShowNormalsBtn->setText(TR("id_show_normals_btn"));
267  _pShowNormalsBtn->setToolTip(TR("id_show_normals_btn"));
268  _pShowNormalsBtn->setCheckable(true);
269  _pShowNormalsBtn->setChecked(false);
270  _pShowNormalsBtn->setFixedSize(24, 24);
271  _pCtrlLayout->addWidget(_pShowNormalsBtn, 0);
272  connect(_pShowNormalsBtn, &QToolButton::toggled, this, &TYModelerFrame::showNormals);
273  showNormals(_pShowNormalsBtn->isChecked());
274 
275  // Btn Show Plafond
276  _pShowPlafondBtn = new QToolButton(this);
277  _pShowPlafondBtn->setIcon(QPixmap(IMG("id_icon_plafond")));
278  _pShowPlafondBtn->setText(TR("id_show_plafond_btn"));
279  _pShowPlafondBtn->setToolTip(TR("id_show_plafond_btn"));
280  _pShowPlafondBtn->setCheckable(true);
281  _pShowPlafondBtn->setChecked(false);
282  _pShowPlafondBtn->setFixedSize(24, 24);
283  _pCtrlLayout->addWidget(_pShowPlafondBtn, 0);
284  connect(_pShowPlafondBtn, &QToolButton::toggled, this, &TYModelerFrame::showPlafond);
285  showPlafond(_pShowPlafondBtn->isChecked());
286 
287  // Btn Show Rayons
288  _pShowRaysBtn = new QToolButton(this);
289  _pShowRaysBtn->setIcon(QPixmap(IMG("id_icon_rays")));
290  _pShowRaysBtn->setText(TR("id_show_rays_btn"));
291  _pShowRaysBtn->setToolTip(TR("id_show_rays_btn"));
292 
293  _pShowRaysBtn->setCheckable(true);
294  _pShowRaysBtn->setChecked(false);
295  _pShowRaysBtn->setFixedSize(24, 24);
296  _pCtrlLayout->addWidget(_pShowRaysBtn, 0);
297  connect(_pShowRaysBtn, &QToolButton::toggled, this, &TYModelerFrame::showRays);
298  showRays(_pShowRaysBtn->isChecked());
299 
300  // Vue graphique
301  _pView = new TYRenderWindowInteractor(this, "vue graphique");
302  _pLayout->addWidget(_pView, 1, 0);
303 
304  QObject::connect(_pView, &TYRenderWindowInteractor::mouseMoved, this, &TYModelerFrame::updateCurPosInfo);
305 
306  // Status bar
307  _pStatusBar = new QStatusBar(this);
308  _pLayout->addWidget(_pStatusBar, 2, 0);
309 
310  // Cameras pour chaque type de vue
311  QVector3D fromTop{0, 10000, 0};
312  QVector3D toTop{0, 0, 0};
313  QVector3D upTop{0, 0, -1};
314  _pOGLCameras[TopView] = new OGLCamera(fromTop, toTop, upTop, 100, 100, PARALLEL);
315 
316  QVector3D fromBottom{0, -10000, 0};
317  QVector3D toBottom{0, 0, 0};
318  QVector3D upBottom{0, 0, -1};
319  _pOGLCameras[BottomView] = new OGLCamera(fromBottom, toBottom, upBottom, 100, 100, PARALLEL);
320 
321  QVector3D fromLeft{-500, 0, 0};
322  QVector3D toLeft{0, 0, 0};
323  QVector3D upLeft{0, 1, 0};
324  _pOGLCameras[LeftView] = new OGLCamera(fromLeft, toLeft, upLeft, 100, 100, PARALLEL);
325 
326  QVector3D fromRight{500, 0, 0};
327  QVector3D toRight{0, 0, 0};
328  QVector3D upRight{0, 1, 0};
329  _pOGLCameras[RightView] = new OGLCamera(fromRight, toRight, upRight, 100, 100, PARALLEL);
330 
331  QVector3D fromFront{0, 0, 500};
332  QVector3D toFront{0, 0, 0};
333  QVector3D upFront{0, 1, 0};
334  _pOGLCameras[FrontView] = new OGLCamera(fromFront, toFront, upFront, 100, 100, PARALLEL);
335 
336  QVector3D fromRear{0, 0, -500};
337  QVector3D toRear{0, 0, 0};
338  QVector3D upRear{0, 1, 0};
339  _pOGLCameras[RearView] = new OGLCamera(fromRear, toRear, upRear, 100, 100, PARALLEL);
340 
341  QVector3D fromPersp{0, 10000, 10000};
342  QVector3D toPersp{0, 0, 0};
343  QVector3D upPersp{0, 1, 0};
344  _pOGLCameras[PerspView] = new OGLCamera(fromPersp, toPersp, upPersp, 100, 100, PERSPECTIVE);
345 
346  QVector3D fromFree{0, 0, 0};
347  QVector3D toFree{0, 0, 0.1};
348  QVector3D upFree{0, 1, 0};
349  _pOGLCameras[FreeView] = new OGLCamera(fromFree, toFree, upFree, 100, 100, FREE);
350 
351  // Triedre XYZ
352  _pOGLLineElementAxeX = new OGLLineElement();
353  _pOGLLineElementAxeX->setColor(OColor(0, 0, 1));
354  _pOGLLineElementAxeX->setVisibility(true);
355  _pOGLLineElementAxeX->setIs3D(true);
356  _pOGLLineElementAxeY = new OGLLineElement();
357  _pOGLLineElementAxeY->setColor(OColor(0, 0, 1));
358  _pOGLLineElementAxeY->setVisibility(true);
359  _pOGLLineElementAxeY->setIs3D(true);
360  _pOGLLineElementAxeZ = new OGLLineElement();
361  _pOGLLineElementAxeZ->setColor(OColor(0, 0, 1));
362  _pOGLLineElementAxeZ->setVisibility(true);
363  _pOGLLineElementAxeZ->setIs3D(true);
364 
365  _pOGLTextElementLabelX = new OGLTextElement();
366  _pOGLTextElementLabelX->setTextToDisplay("X");
367  _pOGLTextElementLabelX->setFont(IMG("id_font_bold"));
368  OColor oColor;
369  oColor.r = fontColor[0];
370  oColor.g = fontColor[1];
371  oColor.b = fontColor[2];
372  _pOGLTextElementLabelX->setColor(OColor(0, 0, 0));
373  _pOGLTextElementLabelX->setVisibility(true);
374 
375  _pOGLTextElementLabelY = new OGLTextElement();
376  _pOGLTextElementLabelY->setTextToDisplay("Y");
377  _pOGLTextElementLabelY->setFont(IMG("id_font_bold"));
378  _pOGLTextElementLabelY->setColor(OColor(0, 0, 0));
379  _pOGLTextElementLabelY->setVisibility(true);
380 
381  _pOGLTextElementLabelZ = new OGLTextElement();
382  _pOGLTextElementLabelZ->setTextToDisplay("Z");
383  _pOGLTextElementLabelZ->setFont(IMG("id_font_bold"));
384  _pOGLTextElementLabelZ->setColor(OColor(0, 0, 0));
385  _pOGLTextElementLabelZ->setVisibility(true);
386 
387  _pView->getRenderer()->addOGLElement(_pOGLLineElementAxeX);
388  _pView->getRenderer()->addOGLElement(_pOGLLineElementAxeY);
389  _pView->getRenderer()->addOGLElement(_pOGLLineElementAxeZ);
390  _pView->getRenderer()->addOGLElement(_pOGLTextElementLabelX);
391  _pView->getRenderer()->addOGLElement(_pOGLTextElementLabelY);
392  _pView->getRenderer()->addOGLElement(_pOGLTextElementLabelZ);
393 
394  // Label
395  _pOGLTextElement = new OGLTextElement();
396  _pOGLTextElement->setTextToDisplay("");
397  _pOGLTextElement->setFont(IMG("id_font_bold"));
398  _pOGLTextElement->setColor(oColor);
399  _pOGLTextElement->setVisibility(true);
400  _pView->getRenderer()->addOGLElement(_pOGLTextElement);
401 
402 #ifndef NO_GRID
403  // Construction de la grille
404  _pOGLGridElement = new OGLGridElement();
405  _pOGLGridElement->setColor(OColor(gridColor[0], gridColor[1], gridColor[2]));
406  _pOGLGridElement->setVisibility(true);
407  _pOGLGridElement->setIs3D(true);
408  _pView->getRenderer()->addOGLElement(_pOGLGridElement);
409 #endif // NO_GRID
410 
411  // Axes de la grille
412  _pOGLLineElementX = new OGLLineElement();
413  _pOGLLineElementX->setPoint1(QVector3D(-100, 0, 0));
414  _pOGLLineElementX->setPoint2(QVector3D(100, 0, 0));
415  _pOGLLineElementX->setColor(OColor(0, 0, 0));
416  _pOGLLineElementX->setVisibility(true);
417  _pOGLLineElementX->setIs3D(true);
418  _pOGLLineElementX->setLineWidth(2.0);
419 
420  _pOGLLineElementY = new OGLLineElement();
421  _pOGLLineElementY->setPoint1(QVector3D(0, -100, 0));
422  _pOGLLineElementY->setPoint2(QVector3D(0, 100, 0));
423  _pOGLLineElementY->setColor(OColor(0, 0, 0));
424  _pOGLLineElementY->setVisibility(true);
425  _pOGLLineElementY->setIs3D(true);
426  _pOGLLineElementY->setLineWidth(2.0);
427 
428  _pView->getRenderer()->addOGLElement(_pOGLLineElementX);
429  _pView->getRenderer()->addOGLElement(_pOGLLineElementY);
430 
431  // Echelle
432  _pOGLScalarBarElement = new OGLScalarBarElement();
433  _pOGLScalarBarElement->setPosition(QVector3D(100, 50, 0));
434  _pOGLScalarBarElement->setSizes(100, 8);
435  _pOGLScalarBarElement->initPositions();
436  _pOGLScalarBarElement->setFont(IMG("id_font"));
437  _pOGLScalarBarElement->setFontColor(OColor(0, 0, 0));
438  _pOGLScalarBarElement->setTexts("0", "0", "0");
439  _pOGLScalarBarElement->setVisibility(true);
440  _pView->getRenderer()->addOGLElement(_pOGLScalarBarElement);
441 
442  // Lumieres
443  _pLightElement = new OGLLightElement();
444  _pLightElement->init(0, OPoint3D(0.0, 400.0, 0.0), 1.0f);
445  _pView->getRenderer()->addLight(_pLightElement);
446 
447  // Couleur de fond
448  getRenderer()->setBackground(rendererColor);
449 
450  // Type de rendu
451  setRenderMode(TYOpenGLRenderer::Surface, true);
452 
453  _wireframeOnMovingCamera = false;
454  _lastRenderMode = getRenderMode();
455 
456  // Gestion du picking
457  _pPicker = new TYElementPicker(this);
458 
459  // Passage en vue de dessus.
460  setViewType(TopView);
461 
462  // Editors
463  _pCameraEditor = new TYCameraEditor(this);
464  _pCameraZoneEditor = new TYCameraZoneEditor(this);
465  _pDistanceEditor = new TYDistanceEditor(this);
466  _pPositionEditor = new TYPositionEditor(this);
467 
468  // Le pick editor
469  _pPickEditor = new TYPickEditor(this);
470  _pPickEditor->connect();
471 
472  // Mode d'edition
473  setEditorModeToCamera();
474 
475  resizeGrid();
476  showGrid(_pGridBtn->isChecked());
477  showScale(_pShowScale->isChecked());
478 
479  // Chargement des preferences
480  updatePreferences();
481 
482  showMaximized();
483 }
484 
485 TYModelerFrame::~TYModelerFrame()
486 {
487 
488  // Disambiguate the overloaded signal QComboBox::activated
489  void (QComboBox::*_qComboBox_activated)(int) = &QComboBox::activated;
490 
491  disconnect(_pViewTypeBox, _qComboBox_activated, this, &TYModelerFrame::setViewType);
492  disconnect(_pRenderModeBox, _qComboBox_activated, this, &TYModelerFrame::setRenderModeSlot);
493  disconnect(_pGridBtn, &QToolButton::toggled, this, &TYModelerFrame::showGrid);
494  disconnect(_pShowScale, &QToolButton::toggled, this, &TYModelerFrame::showScale);
495  disconnect(_pSnapGridBtn, &QToolButton::toggled, this, &TYModelerFrame::setSnapGridActive);
496  disconnect(_pSetCameraCoordinatesBtn, &QToolButton::clicked, this, &TYModelerFrame::setCameraCoordinates);
497  disconnect(_pScreenShotBtn, &QToolButton::clicked, this, &TYModelerFrame::screenShot);
498  disconnect(_pShowSourcesBtn, &QToolButton::toggled, this, &TYModelerFrame::showSources);
499  disconnect(_pShowNormalsBtn, &QToolButton::toggled, this, &TYModelerFrame::showNormals);
500  disconnect(_pShowPlafondBtn, &QToolButton::toggled, this, &TYModelerFrame::showPlafond);
501  disconnect(_pShowRaysBtn, &QToolButton::toggled, this, &TYModelerFrame::showRays);
502  disconnect(_pView, &TYRenderWindowInteractor::mouseMoved, this, &TYModelerFrame::updateCurPosInfo);
503 
504  delete _pCameraEditor;
505  delete _pCameraZoneEditor;
506  delete _pDistanceEditor;
507  delete _pPositionEditor;
508  delete _pPickEditor;
509  delete _pPicker;
510 
511  for (int i = 0; i < NbOfViews; i++)
512  {
513  delete _pOGLCameras[i];
514  _pOGLCameras[i] = NULL;
515  }
516 
517  _pView->getRenderer()->removeOGLElement(_pOGLLineElementAxeX);
518  delete _pOGLLineElementAxeX;
519  _pView->getRenderer()->removeOGLElement(_pOGLLineElementAxeY);
520  delete _pOGLLineElementAxeY;
521  _pView->getRenderer()->removeOGLElement(_pOGLLineElementAxeZ);
522  delete _pOGLLineElementAxeZ;
523  _pView->getRenderer()->removeOGLElement(_pOGLTextElementLabelX);
524  delete _pOGLTextElementLabelX;
525  _pView->getRenderer()->removeOGLElement(_pOGLTextElementLabelY);
526  delete _pOGLTextElementLabelY;
527  _pView->getRenderer()->removeOGLElement(_pOGLTextElementLabelZ);
528  delete _pOGLTextElementLabelZ;
529 
530  _pView->getRenderer()->removeOGLElement(_pOGLTextElement);
531  delete _pOGLTextElement;
532  _pView->getRenderer()->removeOGLElement(_pOGLScalarBarElement);
533  delete _pOGLScalarBarElement;
534  _pView->getRenderer()->removeOGLElement(_pOGLLineElementX);
535  delete _pOGLLineElementX;
536  _pView->getRenderer()->removeOGLElement(_pOGLLineElementY);
537  delete _pOGLLineElementY;
538 
539 #ifndef NO_GRID
540  _pView->getRenderer()->removeOGLElement(_pOGLGridElement);
541  delete _pOGLGridElement;
542 #endif // NO_GRID
543  _pView->getRenderer()->removeLights();
544  delete _pLightElement;
545  delete _pView;
546  _pView = nullptr;
547 }
548 
549 void TYModelerFrame::addScreenShotBtn()
550 {
551  _pCtrlLayout->addSpacing(7);
552  _pCtrlLayout->addWidget(_pScreenShotBtn, 0);
553  _pCtrlLayout->addWidget(_pCopyBtn, 0);
554 }
555 
556 bool TYModelerFrame::close()
557 {
558  return QWidget::close();
559 }
560 
561 bool TYModelerFrame::isElementInCurrentCalcul()
562 {
563  bool ret = false;
564 
565  if (getTYApp()->getCurProjet() && getTYApp()->getCurProjet()->getCurrentCalcul() && _pElement)
566  {
567  // L'element fait-il parti de la selection du calcul courant ?
568  ret = getTYApp()->getCurProjet()->getCurrentCalcul()->isInSelection(_pElement);
569  }
570 
571  return ret;
572 }
573 
574 bool TYModelerFrame::isElementInCurrentProjet()
575 {
576  bool ret = false;
577 
578  if (getTYApp()->getCurProjet() && _pElement)
579  {
580  // On commence directement a partir de l'element lui-meme
581  TYElement* pParent = _pElement;
582 
583  while (pParent)
584  {
585  // Le parent est le projet courant ?
586  if (pParent == getTYApp()->getCurProjet())
587  {
588  ret = true;
589  break;
590  }
591  // Parent du parent
592  pParent = pParent->getParent();
593  }
594  }
595 
596  return ret;
597 }
598 
599 bool TYModelerFrame::askForResetResultat()
600 {
601  bool ret = true;
602 
603  if (isElementInCurrentCalcul())
604  {
605  ret = getTYApp()->getCalculManager()->askForResetResultat();
606  }
607 
608  return ret;
609 }
610 
611 void TYModelerFrame::setViewType(int view)
612 {
613  if (view >= NbOfViews)
614  {
615  return;
616  }
617 
618  // View type
619  _curViewType = view;
620 
621  bool showGridXY = false;
622  bool showGridXZ = false;
623  bool showGridZY = false;
624  QString labelStr;
625 
626  // Pre traitement selon la vue activee
627  switch (view)
628  {
629  case TopView:
630  showGridXZ = _showGrid;
631  labelStr = TR("id_top_view");
632  _pSetCameraCoordinatesBtn->setEnabled(false);
633  break;
634  case BottomView:
635  showGridXZ = _showGrid;
636  labelStr = TR("id_bottom_view");
637  _pSetCameraCoordinatesBtn->setEnabled(false);
638  break;
639  case LeftView:
640  showGridZY = _showGrid;
641  labelStr = TR("id_left_view");
642  _pSetCameraCoordinatesBtn->setEnabled(false);
643  break;
644  case RightView:
645  showGridZY = _showGrid;
646  labelStr = TR("id_right_view");
647  _pSetCameraCoordinatesBtn->setEnabled(false);
648  break;
649  case FrontView:
650  showGridXY = _showGrid;
651  labelStr = TR("id_front_view");
652  _pSetCameraCoordinatesBtn->setEnabled(false);
653  break;
654  case RearView:
655  showGridXY = _showGrid;
656  labelStr = TR("id_rear_view");
657  _pSetCameraCoordinatesBtn->setEnabled(false);
658  break;
659  case PerspView:
660  showGridXZ = _showGrid;
661  labelStr = TR("id_3d_view");
662  _pSetCameraCoordinatesBtn->setEnabled(false);
663  break;
664  case FreeView:
665  showGridXZ = _showGrid;
666  labelStr = TR("id_free_view");
667  _pSetCameraCoordinatesBtn->setEnabled(true);
668  break;
669  default:
670  break;
671  }
672 
673  //_pView->setFocus();
674 
675  // Affichage de la grille correspondant au type de vue
676  setGridLinesActorsVisibility(showGridXY, showGridXZ, showGridZY);
677 
678  // Label
679  _pOGLTextElement->setTextToDisplay(labelStr);
680 
681  // Camera
682  OGLCamera* camera = _pOGLCameras[view];
683  _pView->setActiveCamera(camera);
684 
685  // Update l'element associe a ce modeler
686  if (_pElement)
687  {
688  _pElement->updateGraphicTree();
689  _pElement->getGraphicObject()->update(true);
690  }
691 
692  _pView->getRenderer()->invalidateScene();
693  // Updates
694  updateView();
695 
696  _pViewTypeBox->setCurrentIndex(_curViewType);
697  emit viewTypeChanged(_curViewType);
698 }
699 
700 void TYModelerFrame::setRenderModeSlot(int mode)
701 {
702  setRenderMode(static_cast<TYOpenGLRenderer::RenderMode>(mode), true);
703 }
704 
705 void TYModelerFrame::setRenderMode(TYOpenGLRenderer::RenderMode mode, bool bUpdateGL)
706 {
707  if (mode >= TYOpenGLRenderer::NbOfRenderMode)
708  {
709  return;
710  }
711 
712  _pView->getRenderer()->setRenderMode(mode);
713 
714  _pRenderModeBox->setCurrentIndex(mode);
715 
716  if (bUpdateGL == true)
717  {
718  _pView->update();
719  }
720 }
721 
722 void TYModelerFrame::setEditorMode(int mode)
723 {
724  if (!_editorModeAccepted)
725  {
726  getPickEditor()->usePopup(true);
727  getPickEditor()->useHighlight(false);
728 
729  if (_pCurrentEditor)
730  {
731  // We want to be sure that Camera will not zoom unwillingly before disconnecting signals
732  _pCameraEditor->stopCameraZoom();
733  _pCurrentEditor->disconnect();
734  _pCurrentEditor->close();
735  }
736 
737  _editorModeAccepted = true;
738 
739  switch (mode)
740  {
741  case CameraMode:
742  // fit();
743  getPickEditor()->useHighlight(true);
744  _pCurrentEditor = _pCameraEditor;
745  break;
746  case CameraZoneMode:
747  getPickEditor()->useHighlight(true);
748  _pCurrentEditor = _pCameraZoneEditor;
749  break;
750  case DistanceMode:
751  _pCurrentEditor = _pDistanceEditor;
752  break;
753  case MovingMode:
754  _pCurrentEditor = _pPositionEditor;
755  _pPositionEditor->setMode(TYPositionEditor::Moving);
756  break;
757  case RotationMode:
758  _pCurrentEditor = _pPositionEditor;
759  _pPositionEditor->setMode(TYPositionEditor::Rotation);
760  break;
761  case EditionMode:
762  _pCurrentEditor = _pPositionEditor;
763  _pPositionEditor->setMode(TYPositionEditor::Edition);
764  break;
765  case NoMode:
766  default:
767  getPickEditor()->useHighlight(true);
768  _pCurrentEditor = NULL;
769  mode = NoMode;
770  _editorModeAccepted = false;
771  break;
772  }
773  }
774 
775  // On sauve le mode courant
776  _lastEditorMode = mode;
777 
778  // Init
779  if (_pCurrentEditor)
780  {
781  _pCurrentEditor->connect();
782  _pCurrentEditor->init();
783  }
784 
785  // Pour la prochaine requete
786  _editorModeAccepted = false;
787 
788  // The bug goes by here...
789  emit(editorModeChanged(mode));
790 }
791 
792 void TYModelerFrame::showGrid(bool show)
793 {
794  _showGrid = show;
795 
796  _pOGLLineElementX->setVisibility(_showGrid);
797  _pOGLLineElementY->setVisibility(_showGrid);
798 
799  _pGridBtn->setChecked(_showGrid);
800 
801  _pView->getRenderer()->invalidateScene();
802  // Update
803  setViewType(_curViewType);
804 }
805 
806 void TYModelerFrame::showSources()
807 {
808  _showSources = _pShowSourcesBtn->isChecked();
809 
810  if ((_showSources != TYSourceLineicGraphic::_gVisible) ||
811  (_showSources != TYSourceSurfacicGraphic::_gVisible))
812  {
813 
814  TYApplication::setOverrideCursor(QCursor(Qt::WaitCursor));
815 
816  TYSourceLineicGraphic::_gVisible = _showSources;
817  TYSourceSurfacicGraphic::_gVisible = _showSources;
818 
819  if (_pElement && _pElement->getGraphicObject())
820  {
821  // Update l'element associe a ce modeler
822  _pElement->getGraphicObject()->update(true);
823 
824  _pView->getRenderer()->invalidateScene();
825 
826  // Update view
827  updateView();
828  }
829 
830  TYApplication::restoreOverrideCursor();
831  }
832 
833  _pShowSourcesBtn->setChecked(_showSources);
834 }
835 
836 void TYModelerFrame::showRays(bool show)
837 {
838  _showRays = show;
839  if (_showRays != TYRayGraphic::_gVisible)
840  {
841 
842  TYApplication::setOverrideCursor(QCursor(Qt::WaitCursor));
843 
844  TYRayGraphic::_gVisible = _showRays;
845 
846  if (_pElement && _pElement->getGraphicObject())
847  {
848  // Update l'element associe a ce modeler
849  _pElement->getGraphicObject()->update(true);
850 
851  _pView->getRenderer()->invalidateScene();
852 
853  // Update view
854  updateView();
855  }
856 
857  TYApplication::restoreOverrideCursor();
858  }
859 
860  _pShowRaysBtn->setChecked(_showRays);
861 }
862 
863 void TYModelerFrame::setKeepRays(bool keepRays)
864 {
865  _pShowRaysBtn->setEnabled(keepRays);
866 }
867 
868 void TYModelerFrame::showNormals(bool show)
869 {
870  _showNormals = show;
871 
872  if (_showNormals != TYElementGraphic::_gDrawNormals)
873  {
874 
875  TYApplication::setOverrideCursor(QCursor(Qt::WaitCursor));
876 
877  TYElementGraphic::_gDrawNormals = _showNormals;
878 
879  if (_pElement && _pElement->getGraphicObject())
880  {
881  // Update l'element associe a ce modeler
882  _pElement->getGraphicObject()->update(true);
883 
884  _pView->getRenderer()->invalidateScene();
885 
886  // Update view
887  updateView();
888  }
889 
890  TYApplication::restoreOverrideCursor();
891  }
892 
893  _pShowNormalsBtn->setChecked(_showNormals);
894 }
895 
896 void TYModelerFrame::showPlafond(bool show)
897 {
898  _showPlafond = !show; // inversion entre l'etat variable et du bouton
899 
900  if (_showPlafond != TYElementGraphic::_gDrawPlafond)
901  {
902 
903  TYApplication::setOverrideCursor(QCursor(Qt::WaitCursor));
904 
905  TYElementGraphic::_gDrawPlafond = _showPlafond;
906 
907  if (_pElement && _pElement->getGraphicObject())
908  {
909  // Update l'element associe a ce modeler
910  _pElement->getGraphicObject()->update(true);
911 
912  _pView->getRenderer()->invalidateScene();
913 
914  // Update view
915  updateView();
916  }
917 
918  TYApplication::restoreOverrideCursor();
919  }
920 
921  _pShowPlafondBtn->setChecked(!_showPlafond);
922 }
923 
924 void TYModelerFrame::setSnapGridActive(bool state)
925 {
926  _snapGridActive = state;
927  _pSnapGridBtn->setChecked(_snapGridActive);
928 }
929 
930 void TYModelerFrame::setCameraCoordinates()
931 {
932  if ((_pView->getActiveCamera()) && (_pView->getActiveCamera()->cameraType() == FREE))
933  {
934  TYSetCameraCoordinates* pSetCameraCoordinates = new TYSetCameraCoordinates(this);
935  double x = NAN, y = NAN, z = NAN;
936  _pView->getActiveCamera()->getTranslation(x, y, z);
937  pSetCameraCoordinates->setXCoord(x);
938  pSetCameraCoordinates->setYCoord(-z);
939  pSetCameraCoordinates->setZCoord(y);
940  pSetCameraCoordinates->exec();
941 
942  if (pSetCameraCoordinates->result() == QDialog::Accepted)
943  {
944  if (_pView->getActiveCamera())
945  {
946  _pView->getActiveCamera()->setTranslation(pSetCameraCoordinates->getXCoord(),
947  pSetCameraCoordinates->getZCoord(),
948  -pSetCameraCoordinates->getYCoord());
949 
950  // Update view
951  updateView();
952  }
953  }
954  }
955 }
956 
957 void TYModelerFrame::screenShot()
958 {
959  QString filename = QFileDialog::getSaveFileName(this, tr("Save Image"), "",
960  tr("Images PNG (*.png);;Images JPEG (*.jpg *.jpeg)"));
961  if (!filename.isEmpty())
962  {
963  // Snap
964  QImage img = _pView->grabFramebuffer();
965 
966  // Save
967  QPixmap pix = QPixmap::fromImage(img);
968  pix.save(filename);
969  }
970 }
971 
972 void TYModelerFrame::copy()
973 {
974  // Snap
975  QImage img = _pView->grabFramebuffer();
976 
977  // Copie dans le presse papier
978  QClipboard* clipboard = QApplication::clipboard();
979  clipboard->setImage(img);
980 }
981 
982 void TYModelerFrame::print()
983 {
984  LPTYProjet pProjet = getTYApp()->getCurProjet();
985  LPTYCalcul pCalcul = NULL;
986  if (pProjet)
987  {
988  pCalcul = pProjet->getCurrentCalcul();
989  }
990 
991  // Print dialog
992  TYPrintDialog* pDialog = new TYPrintDialog(this);
993 
994  if (pProjet == NULL)
995  {
996  pDialog->_groupBoxProjet->setEnabled(false);
997  }
998  if (pCalcul == NULL)
999  {
1000  pDialog->_groupBoxCalcul->setEnabled(false);
1001  }
1002 
1003  if (_pElement)
1004  {
1005  if (dynamic_cast<TYBatiment*>(_pElement._pObj) != nullptr)
1006  {
1007  pDialog->_groupBoxBatiment->show();
1008  }
1009  else if (dynamic_cast<TYMachine*>(_pElement._pObj) != nullptr)
1010  {
1011  pDialog->_groupBoxMachine->show();
1012  }
1013  else if (dynamic_cast<TYSiteNode*>(_pElement._pObj) != nullptr)
1014  {
1015  pDialog->_groupBoxSite->show();
1016  }
1017  }
1018 
1019  if (pDialog->exec() == QDialog::Accepted)
1020  {
1021  QPrinter* printer = new QPrinter();
1022 
1023  QPrintDialog dialog(printer, this);
1024  if (dialog.exec())
1025  {
1026  QPainter paint(printer);
1027 
1028  double w = double(printer->width());
1029  double h = double(printer->height());
1030  double scalew = w / 700;
1031  double scaleh = h / 700;
1032 
1033  // Snap
1034  QImage img = _pView->grabFramebuffer();
1035  img = img.scaled(int(w * 9 / 10), int(h * 2 / 3), Qt::KeepAspectRatio, Qt::SmoothTransformation);
1036  int x = int(double(printer->width() - img.width()) / 2);
1037  int y = int(double(printer->height() - img.height()) * 1 / 3);
1038  QPixmap pm = QPixmap::fromImage(img);
1039  paint.drawPixmap(x, y, pm);
1040 
1041  paint.setFont(QFont("Times", (int)(10 * scaleh)));
1042  int mid =
1043  int(w / 2) - int(paint.fontMetrics().horizontalAdvance(pDialog->_lineEditTete->text()) / 2);
1044  paint.drawText(mid, 20, pDialog->_lineEditTete->text());
1045 
1046  mid = int(w / 2) - int(paint.fontMetrics().horizontalAdvance(pDialog->_lineEditPied->text()) / 2);
1047  paint.drawText(mid, printer->height() - 20, pDialog->_lineEditPied->text());
1048 
1049  paint.setFont(QFont("Times", (int)(15 * scaleh), QFont::Bold));
1050  mid =
1051  int(w / 2) - int(paint.fontMetrics().horizontalAdvance(pDialog->_lineEditTitre->text()) / 2);
1052  paint.drawText(mid, y - 20, pDialog->_lineEditTitre->text());
1053 
1054  x = int(50 * scalew);
1055  int x1 = int(w / 2);
1056  y = int(double(printer->height()) * 2 / 3 + 20 * scaleh);
1057  int stepy = int(10 * scaleh);
1058  paint.setFont(QFont("Times", (int)(10 * scaleh)));
1059 
1060  if (pProjet)
1061  {
1062  if (pDialog->_checkBoxNomProjet->isChecked())
1063  {
1064  paint.drawText(x, y, TR("id_print_nom_projet"));
1065  paint.drawText(x1, y, pProjet->getName());
1066  y += stepy;
1067  }
1068  if (pDialog->_checkBoxAuteurProjet->isChecked())
1069  {
1070  paint.drawText(x, y, TR("id_print_auteur_projet"));
1071  paint.drawText(x1, y, pProjet->getAuteur());
1072  y += stepy;
1073  }
1074  if (pDialog->_checkBoxDateProjet->isChecked())
1075  {
1076  paint.drawText(x, y, TR("id_print_date_creation"));
1077  paint.drawText(x1, y, pProjet->getDateCreation());
1078  y += stepy;
1079  paint.drawText(x, y, TR("id_print_date_modif"));
1080  paint.drawText(x1, y, pProjet->getDateModif());
1081  y += stepy;
1082  }
1083  if (pDialog->_checkBoxCommentProjet->isChecked())
1084  {
1085  paint.drawText(x, y, TR("id_print_comment"));
1086  paint.drawText(x1, y, pProjet->getComment());
1087  y += stepy;
1088  }
1089  }
1090 
1091  if (pCalcul)
1092  {
1093  y += int(double(stepy) * 1.5);
1094  if (pDialog->_checkBoxNomCalcul->isChecked())
1095  {
1096  paint.drawText(x, y, TR("id_print_nom_calcul"));
1097  paint.drawText(x1, y, pCalcul->getName());
1098  y += stepy;
1099  }
1100  if (pDialog->_checkBoxDateCalcul->isChecked())
1101  {
1102  paint.drawText(x, y, TR("id_print_date_creation"));
1103  paint.drawText(x1, y, pCalcul->getDateCreation());
1104  y += stepy;
1105  paint.drawText(x, y, TR("id_print_date_modif"));
1106  paint.drawText(x1, y, pCalcul->getDateModif());
1107  y += stepy;
1108  }
1109  if (pDialog->_checkBoxCommentCalcul->isChecked())
1110  {
1111  paint.drawText(x, y, TR("id_print_comment"));
1112  paint.drawText(x1, y, pCalcul->getComment());
1113  y += stepy;
1114  }
1115  }
1116 
1117  if (_pElement)
1118  {
1119  y += int(double(stepy) * 1.5);
1120  TYElement* pElement = (TYElement*)_pElement;
1121  if (strcmp(_pElement->getClassName(), "TYBatiment") == 0)
1122  {
1123  TYBatiment* pBatiment = (TYBatiment*)pElement;
1124  if (pDialog->_checkBoxNomBatiment->isChecked())
1125  {
1126  paint.drawText(x, y, TR("id_print_nom_batiment"));
1127  paint.drawText(x1, y, pBatiment->getName());
1128  }
1129  }
1130  else if (strcmp(_pElement->getClassName(), "TYMachine") == 0)
1131  {
1132  TYMachine* pMachine = (TYMachine*)pElement;
1133  if (pDialog->_checkBoxNomMachine->isChecked())
1134  {
1135  paint.drawText(x, y, TR("id_print_nom_machine"));
1136  paint.drawText(x1, y, pMachine->getName());
1137  y += stepy;
1138  }
1139  if (pDialog->_checkBoxConstrMachine->isChecked())
1140  {
1141  paint.drawText(x, y, TR("id_print_constr"));
1142  paint.drawText(x1, y, pMachine->getConstructeur());
1143  y += stepy;
1144  }
1145  if (pDialog->_checkBoxModelMachine->isChecked())
1146  {
1147  paint.drawText(x, y, TR("id_print_model"));
1148  paint.drawText(x1, y, pMachine->getModele());
1149  y += stepy;
1150  }
1151  if (pDialog->_checkBoxCatMachine->isChecked())
1152  {
1153  paint.drawText(x, y, TR("id_print_cat"));
1154  paint.drawText(x1, y, QString().setNum(pMachine->getCategorie()));
1155  y += stepy;
1156  }
1157  if (pDialog->_checkBoxCommentProjet->isChecked())
1158  {
1159  paint.drawText(x, y, TR("id_print_comment"));
1160  paint.drawText(x1, y, pMachine->getCommentaire());
1161  }
1162  }
1163  else
1164  {
1165  TYSiteNode* pSite = dynamic_cast<TYSiteNode*>(pElement);
1166  if (pSite != nullptr)
1167  {
1168  if (pDialog->_checkBoxNomSite->isChecked())
1169  {
1170  paint.drawText(x, y, TR("id_print_nom_site"));
1171  paint.drawText(x1, y, pSite->getName());
1172  }
1173  }
1174  }
1175  }
1176  }
1177 
1178  delete printer;
1179  }
1180 }
1181 
1182 void TYModelerFrame::editElement()
1183 {
1184  if (_pElement)
1185  {
1186  if (_pElement->edit(this) == QDialog::Accepted)
1187  {
1188  emit eltModified(_pElement);
1189  }
1190 
1191  // On update ds ts les cas si un child a ete modifie...
1192  _pElement->getGraphicObject()->update(true);
1193  _pView->getRenderer()->invalidateScene();
1194  updateView(false, false);
1195  }
1196 }
1197 
1198 OBox getBoundingBox(TYElement* pElement)
1199 {
1200  // XBH: version simplifiee et +logique...
1201 
1202  OBox boundingBox;
1203  LPTYElementGraphic pTYElementGraphic = pElement->getGraphicObject();
1204 
1205  if (pTYElementGraphic != NULL)
1206  {
1207  boundingBox = pTYElementGraphic->boundingBox();
1208  }
1209 
1210  return boundingBox;
1211 }
1212 
1213 OBox TYModelerFrame::getGlobalBoundingBox()
1214 {
1215  OBox globalBoundingBox;
1216  if (_pElement)
1217  {
1218  TYElement* pTYElement = (TYElement*)_pElement;
1219  TYProjet* pTYProjet = dynamic_cast<TYProjet*>(pTYElement);
1220  if (pTYProjet != nullptr)
1221  {
1222  TYSiteNode* pTYSiteNode = (TYSiteNode*)pTYProjet->getSite();
1223  pTYElement = pTYSiteNode;
1224  }
1225 
1226  globalBoundingBox = getBoundingBox(pTYElement);
1227  }
1228  return globalBoundingBox;
1229 }
1230 
1231 void TYModelerFrame::fit()
1232 {
1233  for (auto camera : _pOGLCameras)
1234  {
1235  camera->setSize(_pView->getViewport().width(), _pView->getViewport().height());
1236  }
1237 
1238  int visibilityStates[9];
1239 
1240  // Sauvegarde des etats de visibilite des objets graphiques
1241  // de "decoration", ils ne doivent pas participer au recadrage
1242 #ifndef NO_GRID
1243  visibilityStates[0] = _pOGLGridElement->getShowGridXY();
1244  visibilityStates[1] = _pOGLGridElement->getShowGridXZ();
1245  visibilityStates[2] = _pOGLGridElement->getShowGridZY();
1246 #endif // NO_GRID
1247 
1248  setGridLinesActorsVisibility(false, false, false);
1249 
1250  visibilityStates[3] = _pOGLLineElementAxeX->getVisibility();
1251  _pOGLLineElementAxeX->setVisibility(false);
1252  _pOGLLineElementAxeY->setVisibility(false);
1253  _pOGLLineElementAxeZ->setVisibility(false);
1254  visibilityStates[4] = _pOGLTextElementLabelX->getVisibility();
1255  _pOGLTextElementLabelX->setVisibility(false);
1256  visibilityStates[5] = _pOGLTextElementLabelY->getVisibility();
1257  _pOGLTextElementLabelY->setVisibility(false);
1258  visibilityStates[6] = _pOGLTextElementLabelZ->getVisibility();
1259  _pOGLTextElementLabelZ->setVisibility(false);
1260 
1261  visibilityStates[7] = _pOGLLineElementX->getVisibility();
1262  _pOGLLineElementX->setVisibility(false);
1263  visibilityStates[8] = _pOGLLineElementY->getVisibility();
1264  _pOGLLineElementY->setVisibility(false);
1265 
1266  // az-- : pour tests reperes machines:
1267  OBox globalBoundingBox = getGlobalBoundingBox();
1268 
1269  float xMin = globalBoundingBox._min._x;
1270  float xMax = globalBoundingBox._max._x;
1271  float yMin = globalBoundingBox._min._y;
1272  float yMax = globalBoundingBox._max._y;
1273  float zMin = globalBoundingBox._min._z;
1274  float zMax = globalBoundingBox._max._z;
1275  float xDist = std::max(abs(xMin), abs(xMax)) * 2;
1276  float yDist = std::max(abs(yMin), abs(yMax)) * 2;
1277  float zDist = std::max(abs(zMin), abs(zMax)) * 2;
1278 
1279  // Cameras pour chaque type de vue
1280  QVector3D fromTop{0, 10000, 0};
1281  QVector3D toTop{0, 0, 0};
1282  QVector3D upTop{0, 0, -1};
1283  _pOGLCameras[TopView]->setFromToUp(fromTop, toTop, upTop);
1284  _pOGLCameras[TopView]->resetRotations();
1285  _pOGLCameras[TopView]->resetZoom(xDist, yDist);
1286 
1287  QVector3D fromBottom{0, -10000, 0};
1288  QVector3D toBottom{0, 0, 0};
1289  QVector3D upBottom{0, 0, 1};
1290  _pOGLCameras[BottomView]->setFromToUp(fromBottom, toBottom, upBottom);
1291  _pOGLCameras[BottomView]->resetRotations();
1292  _pOGLCameras[BottomView]->resetZoom(xDist, yDist);
1293 
1294  QVector3D fromLeft{-500, 0, 0};
1295  QVector3D toLeft{0, 0, 0};
1296  QVector3D upLeft{0, 1, 0};
1297  _pOGLCameras[LeftView]->setFromToUp(fromLeft, toLeft, upLeft);
1298  _pOGLCameras[LeftView]->resetZoom(yDist, zDist);
1299 
1300  QVector3D fromRight{500, 0, 0};
1301  QVector3D toRight{0, 0, 0};
1302  QVector3D upRight{0, 1, 0};
1303  _pOGLCameras[RightView]->setFromToUp(fromRight, toRight, upRight);
1304  _pOGLCameras[RightView]->resetZoom(yDist, zDist);
1305 
1306  QVector3D fromFront{0, 0, 500};
1307  QVector3D toFront{0, 0, 0};
1308  QVector3D upFront{0, 1, 0};
1309  _pOGLCameras[FrontView]->setFromToUp(fromFront, toFront, upFront);
1310  _pOGLCameras[FrontView]->resetZoom(xDist, zDist);
1311 
1312  QVector3D fromRear{0, 0, -500};
1313  QVector3D toRear{0, 0, 0};
1314  QVector3D upRear{0, 1, 0};
1315  _pOGLCameras[RearView]->setFromToUp(fromRear, toRear, upRear);
1316  _pOGLCameras[RearView]->resetZoom(xDist, zDist);
1317 
1318  QVector3D fromPersp{0, 1000, 1000};
1319  QVector3D toPersp{0, 0, 0};
1320  QVector3D upPersp{0, 1, 0};
1321  _pOGLCameras[PerspView]->setFromToUp(fromPersp, toPersp, upPersp);
1322  _pOGLCameras[PerspView]->resetZoom(xDist, yDist);
1323  _pOGLCameras[PerspView]->resetRotations();
1324  _pOGLCameras[PerspView]->setDistanceStep(30, 70, 30);
1325 
1326  QVector3D fromFree{0, 0, 0};
1327  QVector3D toFree{0, 0, 0.1};
1328  QVector3D upFree{0, 1, 0};
1329  _pOGLCameras[FreeView]->setFromToUp(fromFree, toFree, upFree);
1330  _pOGLCameras[FreeView]->resetZoom();
1331  _pOGLCameras[FreeView]->resetRotations();
1332  _pOGLCameras[FreeView]->setTranslation(0, 2, 0);
1333  _pOGLCameras[FreeView]->setDistanceStep(5, 5, 5);
1334 
1335  // Restauration des etats de visibilite des objets graphiques
1336 #ifndef NO_GRID
1337  setGridLinesActorsVisibility(visibilityStates[0], visibilityStates[1], visibilityStates[2]);
1338 #endif // NO_GRID
1339  _pOGLLineElementAxeX->setVisibility(visibilityStates[3]);
1340  _pOGLLineElementAxeY->setVisibility(visibilityStates[3]);
1341  _pOGLLineElementAxeZ->setVisibility(visibilityStates[3]);
1342  _pOGLTextElementLabelX->setVisibility(visibilityStates[4]);
1343  _pOGLTextElementLabelY->setVisibility(visibilityStates[5]);
1344  _pOGLTextElementLabelZ->setVisibility(visibilityStates[6]);
1345  _pOGLLineElementX->setVisibility(visibilityStates[7]);
1346  _pOGLLineElementY->setVisibility(visibilityStates[8]);
1347 
1348  _pView->getRenderer()->invalidateScene();
1349  updateView();
1350 }
1351 
1352 void TYModelerFrame::updateView(bool clipping /*=true*/, bool axesAndGrid /*=true*/)
1353 {
1354  OGLCamera* activeCamera = _pView->getActiveCamera();
1355  if (activeCamera)
1356  {
1357  QRect viewport = _pView->getViewport();
1358  activeCamera->setSize(viewport.width(), viewport.height());
1359  if (axesAndGrid)
1360  {
1361  updateAxes();
1362  updateGrid();
1363  updateCurPosInfo(0, 0);
1364  updateScale();
1365  }
1366 
1367  if (clipping)
1368  {
1369  // Update le render mode
1370  setRenderMode(getRenderMode(), false);
1371  }
1372  _pOGLTextElement->setDisplayPosition(7, viewport.height() - 20);
1373  _pOGLScalarBarElement->setPosition(
1374  QVector3D(viewport.width() - _pOGLScalarBarElement->getWidth() * 0.5 - 50, 50, 0));
1375  _pOGLScalarBarElement->initPositions();
1376 
1377  // RNU
1378  //_pView->getRenderer()->invalidateScene();
1379 
1380  // Update la vue 3D
1381  _pView->update();
1382  }
1383 }
1384 
1385 void TYModelerFrame::updateAxes()
1386 {
1387  _pOGLLineElementAxeX->setVisibility(true);
1388  _pOGLLineElementAxeY->setVisibility(true);
1389  _pOGLLineElementAxeZ->setVisibility(true);
1390  _pOGLTextElementLabelX->setVisibility(true);
1391  _pOGLTextElementLabelY->setVisibility(true);
1392  _pOGLTextElementLabelZ->setVisibility(true);
1393 
1394  QVector3D org = _pView->getViewport().displayToWorld(QVector3D(50, 50, 0.1));
1395 
1396  _pOGLLineElementAxeX->setPoint1(org);
1397  _pOGLLineElementAxeY->setPoint1(org);
1398  _pOGLLineElementAxeZ->setPoint1(org);
1399 
1400  QVector3D extX, extY, extZ;
1401 
1402  switch (getCurrentView())
1403  {
1404  case TopView:
1405  {
1406  extX = _pView->getViewport().displayToWorld(QVector3D(90, 50, 0.1));
1407  extY = _pView->getViewport().displayToWorld(QVector3D(50, 90, 0.1));
1408  extZ = _pView->getViewport().displayToWorld(QVector3D(50, 50, 40.1));
1409  _pOGLTextElementLabelX->setDisplayPosition(90, 50);
1410  _pOGLTextElementLabelY->setDisplayPosition(50, 90);
1411  _pOGLTextElementLabelZ->setDisplayPosition(52, 50);
1412  }
1413  break;
1414  case BottomView:
1415  {
1416  extX = _pView->getViewport().displayToWorld(QVector3D(10, 50, 0.1));
1417  extY = _pView->getViewport().displayToWorld(QVector3D(50, 90, 0.1));
1418  extZ = _pView->getViewport().displayToWorld(QVector3D(50, 50, -40.1));
1419  _pOGLTextElementLabelX->setDisplayPosition(10, 50);
1420  _pOGLTextElementLabelY->setDisplayPosition(50, 90);
1421  _pOGLTextElementLabelZ->setDisplayPosition(52, 50);
1422  }
1423  break;
1424  case LeftView:
1425  {
1426  extX = _pView->getViewport().displayToWorld(QVector3D(50, 50, 40.1));
1427  extY = _pView->getViewport().displayToWorld(QVector3D(10, 50, 0.1));
1428  extZ = _pView->getViewport().displayToWorld(QVector3D(50, 90, 0.1));
1429  _pOGLTextElementLabelX->setDisplayPosition(52, 50);
1430  _pOGLTextElementLabelY->setDisplayPosition(10, 50);
1431  _pOGLTextElementLabelZ->setDisplayPosition(50, 90);
1432  }
1433  break;
1434  case RightView:
1435  {
1436  extX = _pView->getViewport().displayToWorld(QVector3D(50, 50, -40.1));
1437  extY = _pView->getViewport().displayToWorld(QVector3D(90, 50, 0.1));
1438  extZ = _pView->getViewport().displayToWorld(QVector3D(50, 90, 0.1));
1439  _pOGLTextElementLabelX->setDisplayPosition(52, 50);
1440  _pOGLTextElementLabelY->setDisplayPosition(90, 50);
1441  _pOGLTextElementLabelZ->setDisplayPosition(50, 90);
1442  }
1443  break;
1444  case FrontView:
1445  {
1446  extX = _pView->getViewport().displayToWorld(QVector3D(90, 50, 0.1));
1447  extY = _pView->getViewport().displayToWorld(QVector3D(50, 50, 40.1));
1448  extZ = _pView->getViewport().displayToWorld(QVector3D(50, 90, 0.1));
1449  _pOGLTextElementLabelX->setDisplayPosition(90, 50);
1450  _pOGLTextElementLabelY->setDisplayPosition(52, 50);
1451  _pOGLTextElementLabelZ->setDisplayPosition(50, 90);
1452  }
1453  break;
1454  case RearView:
1455  {
1456  extX = _pView->getViewport().displayToWorld(QVector3D(10, 50, 0.1));
1457  extY = _pView->getViewport().displayToWorld(QVector3D(50, 50, -40.1));
1458  extZ = _pView->getViewport().displayToWorld(QVector3D(50, 90, 0.1));
1459  _pOGLTextElementLabelX->setDisplayPosition(10, 50);
1460  _pOGLTextElementLabelY->setDisplayPosition(52, 50);
1461  _pOGLTextElementLabelZ->setDisplayPosition(50, 90);
1462  }
1463  break;
1464  case PerspView:
1465  case FreeView:
1466  {
1467  QVector3D org2 = _pView->getViewport().displayToWorld(QVector3D(50, 90, 0.1));
1468  double dist = org.distanceToPoint(org2);
1469  extX.setX(org.x() + dist);
1470  extX.setY(org.y());
1471  extX.setZ(org.z());
1472  extY.setX(org.x());
1473  extY.setY(org.y());
1474  extY.setZ(org.z() - dist);
1475  extZ.setX(org.x());
1476  extZ.setY(org.y() + dist);
1477  extZ.setZ(org.z());
1478 
1479  QVector3D dispX = _pView->getViewport().worldToDisplay(extX);
1480  QVector3D dispY = _pView->getViewport().worldToDisplay(extY);
1481  QVector3D dispZ = _pView->getViewport().worldToDisplay(extZ);
1482 
1483  _pOGLTextElementLabelX->setDisplayPosition(dispX.x(), dispX.y());
1484  _pOGLTextElementLabelY->setDisplayPosition(dispY.x(), dispY.y());
1485  _pOGLTextElementLabelZ->setDisplayPosition(dispZ.x(), dispZ.y());
1486  }
1487  break;
1488  }
1489 
1490  _pOGLLineElementAxeX->setPoint2(extX);
1491  _pOGLLineElementAxeY->setPoint2(extY);
1492  _pOGLLineElementAxeZ->setPoint2(extZ);
1493 }
1494 
1495 void TYModelerFrame::keyPressEvent(QKeyEvent* pEvent)
1496 {
1497  switch (pEvent->key())
1498  {
1499  case Qt::Key_1:
1500  setViewType(TopView);
1501  break;
1502  case Qt::Key_2:
1503  setViewType(LeftView);
1504  break;
1505  case Qt::Key_3:
1506  setViewType(FrontView);
1507  break;
1508  case Qt::Key_4:
1509  setViewType(PerspView);
1510  break;
1511  case Qt::Key_5:
1512  setViewType(FreeView);
1513  break;
1514  case Qt::Key_V:
1515  setViewType((getCurrentView() + 1) % NbOfViews);
1516  break;
1517  case Qt::Key_I:
1518  _pView->showInfos(!_pView->getShowInfos());
1519  break;
1520  case Qt::Key_G:
1521  showGrid(!_showGrid);
1522  break;
1523  case Qt::Key_R:
1524  {
1525  int nextRenderMode = (getRenderMode() + 1) % TYOpenGLRenderer::NbOfRenderMode;
1526  setRenderMode(static_cast<TYOpenGLRenderer::RenderMode>(nextRenderMode), true);
1527  break;
1528  }
1529  case Qt::Key_W:
1530  setRenderMode(TYOpenGLRenderer::Wireframe, true);
1531  break;
1532  case Qt::Key_S:
1533  setRenderMode(TYOpenGLRenderer::Surface, true);
1534  break;
1535  case Qt::Key_Control:
1536  setSnapGridActive(false);
1537  break;
1538  case Qt::Key_C:
1539  if (pEvent->modifiers() == Qt::ControlModifier)
1540  {
1541  copy();
1542  }
1543  else
1544  {
1545  setEditorModeToCamera();
1546  }
1547  break;
1548  case Qt::Key_F:
1549  case Qt::Key_F5:
1550  fit();
1551  break;
1552  default:
1553  TYApplication::sendEvent(_pView, pEvent);
1554  }
1555 }
1556 
1557 void TYModelerFrame::keyReleaseEvent(QKeyEvent* pEvent)
1558 {
1559  switch (pEvent->key())
1560  {
1561  case Qt::Key_Control:
1562  setSnapGridActive(true);
1563  break;
1564  default:
1565  TYApplication::sendEvent(_pView, pEvent);
1566  }
1567 }
1568 
1569 void TYModelerFrame::mouseMoveEvent(QMouseEvent* pEvent) {}
1570 
1571 void TYModelerFrame::updateCurPosInfo(int x, int y)
1572 {
1573  // On recupere la pos du curseur
1574 
1575  // Calcul des coords
1576  float* pos = new float[3];
1577 
1578  if (computeCurPos(x, y, pos))
1579  {
1580  // Si la grille magnetique est activee
1581  if (getSnapGridActive())
1582  {
1583  TYAbstractSceneEditor::snapToGrid(pos[0], pos[1], pos[2], _gridMagnStep);
1584  }
1585 
1586  // Formatage du msg
1587  QString msg("pos : (%1, %2, %3)");
1588  // On inverse y et z, et -y... (VTK to TY)
1589  msg = msg.arg(pos[0], 0, 'f', 2).arg(-pos[2], 0, 'f', 2).arg(pos[1], 0, 'f', 2);
1590  // Affichage
1591  statusBar()->showMessage(msg);
1592  }
1593  else
1594  {
1595  if (getCurrentView() == FreeView)
1596  {
1597  double x = NAN, y = NAN, z = NAN;
1598  _pView->getActiveCamera()->getTranslation(x, y, z);
1599  QString msg = QString("camera pos : (%1, %2, %3)").arg(x).arg(-z).arg(y);
1600  statusBar()->showMessage(msg);
1601  }
1602  else
1603  {
1604  statusBar()->showMessage("");
1605  }
1606  }
1607 
1608  delete[] pos;
1609 }
1610 
1611 // float* TYModelerFrame::computeCurPos(int x, int y)
1612 bool TYModelerFrame::computeCurPos(int x, int y, float* ret)
1613 {
1614  int view = getCurrentView();
1615  if ((view != PerspView) && (view != FreeView))
1616  {
1617  // Position du curseur
1618  QVector3D pos =
1619  _pView->getViewport().displayToWorld(QVector3D(x, _pView->getViewport().height() - y, 0));
1620  ret[0] = pos.x();
1621  ret[1] = pos.y();
1622  ret[2] = pos.z();
1623 
1624  switch (getCurrentView())
1625  {
1626  case TopView:
1627  ret[1] = 0.0;
1628  break;
1629  case BottomView:
1630  ret[1] = 0.0;
1631  break;
1632  case LeftView:
1633  ret[0] = 0.0;
1634  break;
1635  case RightView:
1636  ret[0] = 0.0;
1637  break;
1638  case FrontView:
1639  ret[2] = 0.0;
1640  break;
1641  case RearView:
1642  ret[2] = 0.0;
1643  break;
1644  }
1645 
1646  return true;
1647  }
1648 
1649  return false;
1650 }
1651 
1652 float TYModelerFrame::getDefaultZCoord()
1653 {
1654  return _defaultZCoord;
1655 }
1656 
1657 void TYModelerFrame::setGridLinesActorsVisibility(bool showGridXY, bool showGridXZ, bool showGridZY)
1658 {
1659 #ifndef NO_GRID
1660  _pOGLGridElement->setShowGridXY(showGridXY);
1661  _pOGLGridElement->setShowGridXZ(showGridXZ);
1662  _pOGLGridElement->setShowGridZY(showGridZY);
1663 #endif // NO_GRID
1664 }
1665 
1666 void TYModelerFrame::wheelEvent(QWheelEvent* pEvent)
1667 {
1668  // Reroute l'event sur le TYRenderWindowInteractor
1669  TYApplication::sendEvent(_pView, pEvent);
1670 }
1671 
1672 void TYModelerFrame::resizeEvent(QResizeEvent* pEvent)
1673 {
1674  // CLM-NT33 : maximized handling and main window title
1675  emit frameResized();
1676  updateView();
1677 }
1678 
1679 void TYModelerFrame::focusInEvent(QFocusEvent* pEvent)
1680 {
1681  updateView();
1682 }
1683 
1684 void TYModelerFrame::showEvent(QShowEvent* pEvent)
1685 {
1686  if (_firstTimeShown)
1687  {
1688  TYPreferenceManager::loadGeometryFromPreferences(metaObject()->className(), this);
1689  _firstTimeShown = false;
1690  }
1691  updateView();
1692 }
1693 
1694 void TYModelerFrame::closeEvent(QCloseEvent* pEvent)
1695 {
1696  TYPreferenceManager::saveGeometryToPreferences(metaObject()->className(), this);
1697  pEvent->accept();
1698  emit frameResized();
1699  emit aboutToClose();
1700 
1701  // CLM-NT35 : Gestion du maximized et titre fenetre principal
1702 }
1703 
1704 void TYModelerFrame::enterEvent(QEvent* pEvent)
1705 {
1706  /* _pView->getRenderer()->invalidateScene();
1707  updateView();
1708  _pView->getRenderer()->invalidateScene();
1709  updateView();*/
1710  emit mouseEnter();
1711 }
1712 
1713 void TYModelerFrame::leaveEvent(QEvent* pEvent)
1714 {
1715  emit mouseLeave();
1716 }
1717 
1718 void TYModelerFrame::updateGrid()
1719 {
1720  if ((getCurrentView() == PerspView) || (getCurrentView() == FreeView))
1721  {
1722  _pOGLLineElementX->setPoint1(QVector3D(0, 0, _gridDimY / 2));
1723  _pOGLLineElementX->setPoint2(QVector3D(0, 0, -_gridDimY / 2));
1724 
1725  _pOGLLineElementY->setPoint1(QVector3D(_gridDimX / 2, 0, 0));
1726  _pOGLLineElementY->setPoint2(QVector3D(-_gridDimX / 2, 0, 0));
1727  }
1728  else
1729  {
1730  QRect viewport = _pView->getViewport();
1731  int gridXMax = viewport.width();
1732  int gridYMax = viewport.height();
1733  if (gridXMax == 0)
1734  {
1735  gridXMax = 100;
1736  }
1737  if (gridYMax == 0)
1738  {
1739  gridYMax = 100;
1740  }
1741 
1742  // getCenter
1743  QVector3D center = _pView->getViewport().worldToDisplay(QVector3D(0, 0, 0));
1744 
1745  // X
1746  QVector3D xAxisPoint1 = _pView->getViewport().displayToWorld(QVector3D(center.x(), 0, 0));
1747  QVector3D xAxisPoint2 = _pView->getViewport().displayToWorld(QVector3D(center.x(), gridYMax, 0));
1748  _pOGLLineElementX->setPoint1(xAxisPoint1);
1749  if (xAxisPoint1 != xAxisPoint2)
1750  {
1751  _pOGLLineElementX->setPoint2(xAxisPoint2);
1752  }
1753 
1754  // Y
1755  QVector3D yAxisPoint1 = _pView->getViewport().displayToWorld(QVector3D(0, center.y(), 0));
1756  QVector3D yAxisPoint2 = _pView->getViewport().displayToWorld(QVector3D(gridXMax, center.y(), 0));
1757  _pOGLLineElementY->setPoint1(yAxisPoint1);
1758  if (yAxisPoint1 != yAxisPoint2)
1759  {
1760  _pOGLLineElementY->setPoint2(yAxisPoint2);
1761  }
1762  }
1763 }
1764 
1765 void TYModelerFrame::updateElementGraphic(bool force /* = false */)
1766 {
1767  if (_pElement && _pElement->getGraphicObject())
1768  {
1769  _pElement->getGraphicObject()->update(force);
1770  }
1771 }
1772 
1773 void TYModelerFrame::resizeGrid()
1774 {
1775  _pOGLGridElement->setGridDimX(_gridDimX);
1776  _pOGLGridElement->setGridDimY(_gridDimY);
1777  _pOGLGridElement->setGridStep(_gridStep);
1778 
1779  _pOGLLineElementX->setColor(OColor(gridColor[0], gridColor[1], gridColor[2]));
1780  _pOGLLineElementY->setColor(OColor(gridColor[0], gridColor[1], gridColor[2]));
1781 }
1782 
1783 void TYModelerFrame::updatePreferences()
1784 {
1785  // Mise a jour de la taille de l'historique de l'Action Manager
1786  if (TYPreferenceManager::exists(TYDIRPREFERENCEMANAGER, "HistoSize"))
1787  {
1788  _actionManager.setHistorySize(TYPreferenceManager::getInt(TYDIRPREFERENCEMANAGER, "HistoSize"));
1789  }
1790  else
1791  {
1792  TYPreferenceManager::setInt(TYDIRPREFERENCEMANAGER, "HistoSize", _actionManager.getHistorySize());
1793  }
1794 
1795  // Mise a jour de l'etat d'activation du delplacement de camera en mode Wireframe
1796  if (TYPreferenceManager::exists(TYDIRPREFERENCEMANAGER, "WireframeOnMovingCamera"))
1797  {
1798  setWireframeOnMovingCamera(
1799  TYPreferenceManager::getBool(TYDIRPREFERENCEMANAGER, "WireframeOnMovingCamera"));
1800  }
1801  else
1802  {
1803  TYPreferenceManager::setBool(TYDIRPREFERENCEMANAGER, "WireframeOnMovingCamera", false);
1804  setWireframeOnMovingCamera(false);
1805  }
1806 
1807  // Mise a jour des couleurs a partir des preferences.
1808  // Couleur de fond
1809  if (TYPreferenceManager::exists(TYDIRPREFERENCEMANAGER, "BackgroundColorR"))
1810  {
1811  float r = NAN, g = NAN, b = NAN;
1812  TYPreferenceManager::getColor(TYDIRPREFERENCEMANAGER, "BackgroundColor", r, g, b);
1813  rendererColor[0] = r / 255;
1814  rendererColor[1] = g / 255;
1815  rendererColor[2] = b / 255;
1816  }
1817  else
1818  {
1819  float r = rendererColor[0] * 255;
1820  float g = rendererColor[1] * 255;
1821  float b = rendererColor[2] * 255;
1822  TYPreferenceManager::setColor(TYDIRPREFERENCEMANAGER, "BackgroundColor", r, g, b);
1823  }
1824 
1825  getRenderer()->setBackground(rendererColor);
1826 
1827  // Couleur de la grille
1828  if (TYPreferenceManager::exists(TYDIRPREFERENCEMANAGER, "GridColorR"))
1829  {
1830  float r = NAN, g = NAN, b = NAN;
1831  TYPreferenceManager::getColor(TYDIRPREFERENCEMANAGER, "GridColor", r, g, b);
1832  gridColor[0] = r / 255;
1833  gridColor[1] = g / 255;
1834  gridColor[2] = b / 255;
1835  }
1836  else
1837  {
1838  float r = gridColor[0] * 255;
1839  float g = gridColor[1] * 255;
1840  float b = gridColor[2] * 255;
1841  TYPreferenceManager::setColor(TYDIRPREFERENCEMANAGER, "GridColor", r, g, b);
1842  }
1843 
1844  // Couleur de la police
1845  if (TYPreferenceManager::exists(TYDIRPREFERENCEMANAGER, "FontColorR"))
1846  {
1847  float r = NAN, g = NAN, b = NAN;
1848  TYPreferenceManager::getColor(TYDIRPREFERENCEMANAGER, "FontColor", r, g, b);
1849  fontColor[0] = r / 255;
1850  fontColor[1] = g / 255;
1851  fontColor[2] = b / 255;
1852  }
1853  else
1854  {
1855  float r = fontColor[0] * 255;
1856  float g = fontColor[1] * 255;
1857  float b = fontColor[2] * 255;
1858  TYPreferenceManager::setColor(TYDIRPREFERENCEMANAGER, "FontColor", r, g, b);
1859  }
1860 
1861  _pOGLTextElementLabelX->setColor(OColor(0, 0, 0));
1862  _pOGLTextElementLabelY->setColor(OColor(0, 0, 0));
1863  _pOGLTextElementLabelZ->setColor(OColor(0, 0, 0));
1864  _pOGLScalarBarElement->setFontColor(OColor(fontColor[0], fontColor[1], fontColor[2]));
1865 
1866  // Mise a jour de l'eclairage de la scene.
1867  float intensity = 0.83f;
1868  if ((TYPreferenceManager::exists(TYDIRPREFERENCEMANAGER, "Luminosite")))
1869  {
1870  intensity = TYPreferenceManager::getDouble(TYDIRPREFERENCEMANAGER, "Luminosite");
1871  }
1872  else
1873  {
1874  TYPreferenceManager::setDouble(TYDIRPREFERENCEMANAGER, "Luminosite", intensity);
1875  }
1876 
1877  if (intensity < 0.1f)
1878  {
1879  intensity = 0.1f;
1880  }
1881  _pLightElement->setIntensity(intensity);
1882 
1883  // Mise a jour de la tolerance du picking.
1884  float precisPick = 3.0;
1885  if (TYPreferenceManager::exists(TYDIRPREFERENCEMANAGER, "PrecisPick"))
1886  {
1887  precisPick = TYPreferenceManager::getFloat(TYDIRPREFERENCEMANAGER, "PrecisPick");
1888  }
1889  else
1890  {
1891  TYPreferenceManager::setFloat(TYDIRPREFERENCEMANAGER, "PrecisPick", precisPick);
1892  }
1893  _pPickEditor->setPickTolerance(precisPick);
1894  _pPositionEditor->setPickPointPrecision(precisPick);
1895 
1896  // Mise a jour du pas de zoom de la mollette de la souris.
1897  float zoomStep = 1.0f;
1898  if (TYPreferenceManager::exists(TYDIRPREFERENCEMANAGER, "ZoomStep"))
1899  {
1900  zoomStep = TYPreferenceManager::getFloat(TYDIRPREFERENCEMANAGER, "ZoomStep");
1901  }
1902  else
1903  {
1904  TYPreferenceManager::setFloat(TYDIRPREFERENCEMANAGER, "ZoomStep", zoomStep);
1905  }
1906  _pCameraEditor->setWheelStep(zoomStep);
1907  _pDistanceEditor->setWheelStep(zoomStep);
1908  _pPositionEditor->setWheelStep(zoomStep);
1909 
1910  // Mise a jour du pas de l'angle du positionEditor
1911  float angle = 15.0;
1912  if (TYPreferenceManager::exists(TYDIRPREFERENCEMANAGER, "Angle"))
1913  {
1914  angle = TYPreferenceManager::getFloat(TYDIRPREFERENCEMANAGER, "Angle");
1915  }
1916  else
1917  {
1918  TYPreferenceManager::setFloat(TYDIRPREFERENCEMANAGER, "Angle", angle);
1919  }
1920 
1921  _pPositionEditor->setAngleStep(angle);
1922 
1923  // Mise a jour des fonctions attachees a la souris.
1924  // 2D
1925  // bouton gauche
1926  int mouseLeftButtonFunct2D = 1;
1927  if (TYPreferenceManager::exists(TYDIRPREFERENCEMANAGER, "MouseLeftButtonFunct2D"))
1928  {
1929  mouseLeftButtonFunct2D =
1930  TYPreferenceManager::getInt(TYDIRPREFERENCEMANAGER, "MouseLeftButtonFunct2D");
1931  }
1932 
1933  else
1934  {
1935  TYPreferenceManager::setInt(TYDIRPREFERENCEMANAGER, "MouseLeftButtonFunct2D", mouseLeftButtonFunct2D);
1936  }
1937 
1938  switch (mouseLeftButtonFunct2D)
1939  {
1940  case 0:
1941  _pCameraEditor->setLeftButtonFunction2D(&TYCameraEditor::cameraZoom);
1942  break;
1943  case 1:
1944  _pCameraEditor->setLeftButtonFunction2D(&TYCameraEditor::cameraTranslate);
1945  break;
1946  }
1947 
1948  // bouton droit
1949  int mouseRightButtonFunct2D = 0;
1950  if (TYPreferenceManager::exists(TYDIRPREFERENCEMANAGER, "MouseRightButtonFunct2D"))
1951  {
1952  mouseRightButtonFunct2D =
1953  TYPreferenceManager::getInt(TYDIRPREFERENCEMANAGER, "MouseRightButtonFunct2D");
1954  }
1955  else
1956  {
1957  TYPreferenceManager::setInt(TYDIRPREFERENCEMANAGER, "MouseRightButtonFunct2D",
1958  mouseRightButtonFunct2D);
1959  }
1960 
1961  switch (mouseRightButtonFunct2D)
1962  {
1963  case 0:
1964  _pCameraEditor->setRightButtonFunction2D(&TYCameraEditor::cameraZoom);
1965  break;
1966  case 1:
1967  _pCameraEditor->setRightButtonFunction2D(&TYCameraEditor::cameraTranslate);
1968  break;
1969  }
1970 
1971  // bouton central
1972  int mouseMiddleButtonFunct2D = 0;
1973  if (TYPreferenceManager::exists(TYDIRPREFERENCEMANAGER, "MouseMiddleButtonFunct2D"))
1974  {
1975  mouseMiddleButtonFunct2D =
1976  TYPreferenceManager::getInt(TYDIRPREFERENCEMANAGER, "MouseMiddleButtonFunct2D");
1977  }
1978  else
1979  {
1980  TYPreferenceManager::setInt(TYDIRPREFERENCEMANAGER, "MouseMiddleButtonFunct2D",
1981  mouseMiddleButtonFunct2D);
1982  }
1983 
1984  switch (mouseMiddleButtonFunct2D)
1985  {
1986  case 0:
1987  _pCameraEditor->setMiddleButtonFunction2D(&TYCameraEditor::cameraZoom);
1988  break;
1989  case 1:
1990  _pCameraEditor->setMiddleButtonFunction2D(&TYCameraEditor::cameraTranslate);
1991  break;
1992  }
1993 
1994  // en 3D
1995  // bouton gauche
1996  int mouseLeftButtonFunct3D = 3;
1997  if (TYPreferenceManager::exists(TYDIRPREFERENCEMANAGER, "MouseLeftButtonFunct3D"))
1998  {
1999  mouseLeftButtonFunct3D =
2000  TYPreferenceManager::getInt(TYDIRPREFERENCEMANAGER, "MouseLeftButtonFunct3D");
2001  }
2002  else
2003  {
2004  TYPreferenceManager::setInt(TYDIRPREFERENCEMANAGER, "MouseLeftButtonFunct3D", mouseLeftButtonFunct3D);
2005  }
2006 
2007  switch (mouseLeftButtonFunct3D)
2008  {
2009  case 0:
2010  _pCameraEditor->setLeftButtonFunction3D(&TYCameraEditor::cameraZoom);
2011  break;
2012  case 1:
2013  _pCameraEditor->setLeftButtonFunction3D(&TYCameraEditor::cameraTranslate);
2014  break;
2015  case 2:
2016  _pCameraEditor->setLeftButtonFunction3D(&TYCameraEditor::cameraRoll);
2017  break;
2018  case 3:
2019  _pCameraEditor->setLeftButtonFunction3D(&TYCameraEditor::cameraRotate);
2020  break;
2021  }
2022 
2023  // bouton droit
2024  int mouseRightButtonFunct3D = 0;
2025  if (TYPreferenceManager::exists(TYDIRPREFERENCEMANAGER, "MouseRightButtonFunct3D"))
2026  {
2027  mouseRightButtonFunct3D =
2028  TYPreferenceManager::getInt(TYDIRPREFERENCEMANAGER, "MouseRightButtonFunct3D");
2029  }
2030  else
2031  {
2032  TYPreferenceManager::setInt(TYDIRPREFERENCEMANAGER, "MouseRightButtonFunct3D",
2033  mouseRightButtonFunct3D);
2034  }
2035 
2036  switch (mouseRightButtonFunct3D)
2037  {
2038  case 0:
2039  _pCameraEditor->setRightButtonFunction3D(&TYCameraEditor::cameraZoom);
2040  break;
2041  case 1:
2042  _pCameraEditor->setRightButtonFunction3D(&TYCameraEditor::cameraTranslate);
2043  break;
2044  case 2:
2045  _pCameraEditor->setRightButtonFunction3D(&TYCameraEditor::cameraRoll);
2046  break;
2047  case 3:
2048  _pCameraEditor->setRightButtonFunction3D(&TYCameraEditor::cameraRotate);
2049  break;
2050  }
2051 
2052  // bouton central
2053  int mouseMiddleButtonFunct3D = 2;
2054  if (TYPreferenceManager::exists(TYDIRPREFERENCEMANAGER, "MouseMiddleButtonFunct3D"))
2055  {
2056  mouseMiddleButtonFunct3D =
2057  TYPreferenceManager::getInt(TYDIRPREFERENCEMANAGER, "MouseMiddleButtonFunct3D");
2058  }
2059  else
2060  {
2061  TYPreferenceManager::setInt(TYDIRPREFERENCEMANAGER, "MouseMiddleButtonFunct3D",
2062  mouseMiddleButtonFunct3D);
2063  }
2064 
2065  switch (mouseMiddleButtonFunct3D)
2066  {
2067  case 0:
2068  _pCameraEditor->setMiddleButtonFunction3D(&TYCameraEditor::cameraZoom);
2069  break;
2070  case 1:
2071  _pCameraEditor->setMiddleButtonFunction3D(&TYCameraEditor::cameraTranslate);
2072  break;
2073  case 2:
2074  _pCameraEditor->setMiddleButtonFunction3D(&TYCameraEditor::cameraRoll);
2075  break;
2076  case 3:
2077  _pCameraEditor->setMiddleButtonFunction3D(&TYCameraEditor::cameraRotate);
2078  break;
2079  }
2080 
2081  // Mode shift.
2082  // 2D
2083  // bouton gauche
2084  int mouseShiftLeftButtonFunct2D = 1;
2085  if (TYPreferenceManager::exists(TYDIRPREFERENCEMANAGER, "MouseShiftLeftButtonFunct2D"))
2086  {
2087  mouseShiftLeftButtonFunct2D =
2088  TYPreferenceManager::getInt(TYDIRPREFERENCEMANAGER, "MouseShiftLeftButtonFunct2D");
2089  }
2090  else
2091  {
2092  TYPreferenceManager::setInt(TYDIRPREFERENCEMANAGER, "MouseShiftLeftButtonFunct2D",
2093  mouseShiftLeftButtonFunct2D);
2094  }
2095 
2096  switch (mouseShiftLeftButtonFunct2D)
2097  {
2098  case 0:
2099  _pCameraEditor->setShiftLeftButtonFunction2D(&TYCameraEditor::cameraZoom);
2100  break;
2101  case 1:
2102  _pCameraEditor->setShiftLeftButtonFunction2D(&TYCameraEditor::cameraTranslate);
2103  break;
2104  }
2105 
2106  // bouton droit
2107  int mouseShiftRightButtonFunct2D = 0;
2108  if (TYPreferenceManager::exists(TYDIRPREFERENCEMANAGER, "MouseShiftRightButtonFunct2D"))
2109  {
2110  mouseShiftRightButtonFunct2D =
2111  TYPreferenceManager::getInt(TYDIRPREFERENCEMANAGER, "MouseShiftRightButtonFunct2D");
2112  }
2113  else
2114  {
2115  TYPreferenceManager::setInt(TYDIRPREFERENCEMANAGER, "MouseShiftRightButtonFunct2D",
2116  mouseShiftRightButtonFunct2D);
2117  }
2118 
2119  switch (mouseShiftRightButtonFunct2D)
2120  {
2121  case 0:
2122  _pCameraEditor->setShiftRightButtonFunction2D(&TYCameraEditor::cameraZoom);
2123  break;
2124  case 1:
2125  _pCameraEditor->setShiftRightButtonFunction2D(&TYCameraEditor::cameraTranslate);
2126  break;
2127  }
2128 
2129  // en 3D
2130  // bouton gauche
2131  int mouseShiftLeftButtonFunct3D = 1;
2132  if (TYPreferenceManager::exists(TYDIRPREFERENCEMANAGER, "MouseShiftLeftButtonFunct3D"))
2133  {
2134  mouseShiftLeftButtonFunct3D =
2135  TYPreferenceManager::getInt(TYDIRPREFERENCEMANAGER, "MouseShiftLeftButtonFunct3D");
2136  }
2137  else
2138  {
2139  TYPreferenceManager::setInt(TYDIRPREFERENCEMANAGER, "MouseShiftLeftButtonFunct3D",
2140  mouseShiftLeftButtonFunct3D);
2141  }
2142 
2143  switch (mouseShiftLeftButtonFunct3D)
2144  {
2145  case 0:
2146  _pCameraEditor->setShiftLeftButtonFunction3D(&TYCameraEditor::cameraZoom);
2147  break;
2148  case 1:
2149  _pCameraEditor->setShiftLeftButtonFunction3D(&TYCameraEditor::cameraTranslate);
2150  break;
2151  case 2:
2152  _pCameraEditor->setShiftLeftButtonFunction3D(&TYCameraEditor::cameraRoll);
2153  break;
2154  case 3:
2155  _pCameraEditor->setShiftLeftButtonFunction3D(&TYCameraEditor::cameraRotate);
2156  break;
2157  }
2158 
2159  // bouton droit
2160  int mouseShiftRightButtonFunct3D = 2;
2161  if (TYPreferenceManager::exists(TYDIRPREFERENCEMANAGER, "MouseShiftRightButtonFunct3D"))
2162  {
2163  mouseShiftRightButtonFunct3D =
2164  TYPreferenceManager::getInt(TYDIRPREFERENCEMANAGER, "MouseShiftRightButtonFunct3D");
2165  }
2166  else
2167  {
2168  TYPreferenceManager::setInt(TYDIRPREFERENCEMANAGER, "MouseShiftRightButtonFunct3D",
2169  mouseShiftRightButtonFunct3D);
2170  }
2171 
2172  switch (mouseShiftRightButtonFunct3D)
2173  {
2174  case 0:
2175  _pCameraEditor->setShiftRightButtonFunction3D(&TYCameraEditor::cameraZoom);
2176  break;
2177  case 1:
2178  _pCameraEditor->setShiftRightButtonFunction3D(&TYCameraEditor::cameraTranslate);
2179  break;
2180  case 2:
2181  _pCameraEditor->setShiftRightButtonFunction3D(&TYCameraEditor::cameraRoll);
2182  break;
2183  case 3:
2184  _pCameraEditor->setShiftRightButtonFunction3D(&TYCameraEditor::cameraRotate);
2185  break;
2186  }
2187 
2188  // Force un update de la camera
2189  _pCameraEditor->setNavigationOnViewType(getCurrentView());
2190 
2191  // Update de l'editor courant
2192  // setEditorMode(_lastEditorMode); // DTn : Correction du bug #0009661
2193 
2194  // Mets a jour la structure graphique de l'element
2195  updateElementGraphic(true);
2196 
2197  // Refresh
2198  updateView(false);
2199 }
2200 
2201 void TYModelerFrame::startMovingRenderMode()
2202 {
2203  TYOpenGLRenderer::RenderMode currentMode = getRenderMode();
2204  // On passe en mode Wireframe si l'option est activee et qu'on est
2205  // pas deja dans ce mode
2206  if (_wireframeOnMovingCamera && (currentMode != TYOpenGLRenderer::Wireframe))
2207  {
2208  // On conserve le mode courant
2209  _lastRenderMode = currentMode;
2210  // On passe en Wireframe
2211  setRenderMode(TYOpenGLRenderer::Wireframe, false);
2212  }
2213 }
2214 
2215 void TYModelerFrame::stopMovingRenderMode()
2216 {
2217  if (_wireframeOnMovingCamera)
2218  {
2219  // On revient dans le mode courant
2220  setRenderMode(_lastRenderMode, true);
2221  }
2222 }
2223 
2224 void TYModelerFrame::updateScale()
2225 {
2226  if (_showScale)
2227  {
2228  QVector3D pt0 = _pView->getViewport().displayToWorld(QVector3D(0.0, 0.0, 0.1));
2229  QVector3D pt1 = _pView->getViewport().displayToWorld(QVector3D(200.0, 0.0, 0.1));
2230 
2231  double value = pt0.distanceToPoint(pt1);
2232 
2233  int i = floor(log10(value));
2234  int n = floor(value / pow(10, i));
2235  if (n == 3 || n == 4)
2236  {
2237  n = 5;
2238  }
2239  else if (n >= 6 && n <= 9)
2240  {
2241  n = 1;
2242  i++;
2243  }
2244  double distanceInRealWorld = n * pow(10, i);
2245  double distanceInDisplayWorld = 200.0 * distanceInRealWorld / value;
2246  QString max = QString().setNum(distanceInRealWorld, 'g', 3);
2247  QString mid = QString().setNum(distanceInRealWorld / 2, 'g', 3);
2248  _pOGLScalarBarElement->setTexts("0", mid.toStdString(), max.toStdString());
2249  _pOGLScalarBarElement->setSizes(distanceInDisplayWorld, 8);
2250  }
2251 }
2252 
2253 void TYModelerFrame::showScale(bool show)
2254 {
2255  _showScale = show;
2256 
2257  _pOGLScalarBarElement->setVisibility(_showScale);
2258 
2259  _pView->getRenderer()->invalidateScene();
2260  updateView(false, true);
2261 }
2262 
2263 double TYModelerFrame::getDouble(const QString& title, const QString& txt, double min, double max, double val,
2264  bool& ok, int dec)
2265 {
2266  QLocale loc = QLocale(QLocale::English);
2267  TYInputDialog dialog{};
2268  dialog.setLocale(loc); // Will use a dot
2269  dialog.setWindowTitle(title);
2270  dialog.setLabelText(txt);
2271  dialog.setDoubleRange(min, max);
2272  dialog.setTextValue(QString::number(val));
2273  dialog.setDoubleValue(val);
2274  dialog.setDoubleDecimals(dec);
2275  dialog.setInputMode(QInputDialog::TextInput);
2276  ok = dialog.exec();
2277  return dialog.doubleValue();
2278 }
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:1198
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:245
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::setLeftButtonFunction2D
void setLeftButtonFunction2D(void(TYCameraEditor::*function)())
Definition: TYCameraEditor.cpp:200
TYCameraEditor::setNavigationOnViewType
void setNavigationOnViewType(int view)
Switch auto entre navi 2D ou 3D.
Definition: TYCameraEditor.cpp:694
TYCameraEditor::setMiddleButtonFunction2D
void setMiddleButtonFunction2D(void(TYCameraEditor::*function)())
Definition: TYCameraEditor.cpp:212
TYCameraEditor::setRightButtonFunction2D
void setRightButtonFunction2D(void(TYCameraEditor::*function)())
Definition: TYCameraEditor.cpp:224
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:1666
TYModelerFrame::_pSnapGridBtn
QToolButton * _pSnapGridBtn
Button to activate the magnetic grid.
Definition: TYModelerFrame.h:542
TYModelerFrame::setSnapGridActive
void setSnapGridActive(bool state)
Definition: TYModelerFrame.cpp:924
TYModelerFrame::closeEvent
virtual void closeEvent(QCloseEvent *pEvent)
Definition: TYModelerFrame.cpp:1694
TYModelerFrame::updateElementGraphic
void updateElementGraphic(bool force=false)
Definition: TYModelerFrame.cpp:1765
TYModelerFrame::leaveEvent
virtual void leaveEvent(QEvent *pEvent)
Definition: TYModelerFrame.cpp:1713
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:1612
TYModelerFrame::_pCameraEditor
TYCameraEditor * _pCameraEditor
Manages the camera.
Definition: TYModelerFrame.h:532
TYModelerFrame::showScale
void showScale(bool show)
Definition: TYModelerFrame.cpp:2253
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:700
TYModelerFrame::_pElement
LPTYElement _pElement
A pointer to the element to edit.
Definition: TYModelerFrame.h:680
TYModelerFrame::showPlafond
void showPlafond(bool show)
Definition: TYModelerFrame.cpp:896
TYModelerFrame::_pShowScale
QToolButton * _pShowScale
Button for displaying the scale.
Definition: TYModelerFrame.h:629
TYModelerFrame::enterEvent
virtual void enterEvent(QEvent *pEvent)
Definition: TYModelerFrame.cpp:1704
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:1672
TYModelerFrame::_pCurrentEditor
TYAbstractSceneEditor * _pCurrentEditor
The current editor.
Definition: TYModelerFrame.h:653
TYModelerFrame::setKeepRays
void setKeepRays(bool keepRays)
Definition: TYModelerFrame.cpp:863
TYModelerFrame::~TYModelerFrame
virtual ~TYModelerFrame()
Definition: TYModelerFrame.cpp:485
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:1657
TYModelerFrame::_pShowPlafondBtn
QToolButton * _pShowPlafondBtn
Button for displaying the ceiling of buildings.
Definition: TYModelerFrame.h:560
TYModelerFrame::showRays
void showRays(bool show)
Definition: TYModelerFrame.cpp:836
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:1679
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:1569
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:611
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:574
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:556
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:1652
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:868
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:930
TYModelerFrame::_pOGLTextElementLabelZ
OGLTextElement * _pOGLTextElementLabelZ
Definition: TYModelerFrame.h:604
TYModelerFrame::isElementInCurrentCalcul
bool isElementInCurrentCalcul()
Definition: TYModelerFrame.cpp:561
TYModelerFrame::askForResetResultat
bool askForResetResultat()
Definition: TYModelerFrame.cpp:599
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:1571
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:2201
TYModelerFrame::_pPicker
TYElementPicker * _pPicker
For picking.
Definition: TYModelerFrame.h:584
TYModelerFrame::setRenderMode
virtual void setRenderMode(TYOpenGLRenderer::RenderMode mode, bool bUpdateGL)
Definition: TYModelerFrame.cpp:705
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:1783
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:1495
TYModelerFrame::_pDistanceEditor
TYDistanceEditor * _pDistanceEditor
Tools for measuring.
Definition: TYModelerFrame.h:587
TYModelerFrame::setEditorMode
virtual void setEditorMode(int mode)
Definition: TYModelerFrame.cpp:722
TYModelerFrame::showGrid
void showGrid(bool show)
Definition: TYModelerFrame.cpp:792
TYModelerFrame::updateView
virtual void updateView(bool clipping=true, bool axesAndGrid=true)
Definition: TYModelerFrame.cpp:1352
TYModelerFrame::showEvent
virtual void showEvent(QShowEvent *pEvent)
Definition: TYModelerFrame.cpp:1684
TYModelerFrame::keyReleaseEvent
virtual void keyReleaseEvent(QKeyEvent *pEvent)
Definition: TYModelerFrame.cpp:1557
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:2263
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 Mon Dec 22 2025 10:42:02 for Code_TYMPAN by doxygen 1.9.1