src/XGUI/XGUI_ViewerProxy.cpp

   1 // Copyright (C) 2014-2019  CEA/DEN, EDF R&D
   2 //
   3 // This library is free software; you can redistribute it and/or
   4 // modify it under the terms of the GNU Lesser General Public
   5 // License as published by the Free Software Foundation; either
   6 // version 2.1 of the License, or (at your option) any later version.
   7 //
   8 // This library 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.  See the GNU
  11 // Lesser General Public License for more details.
  12 //
  13 // You should have received a copy of the GNU Lesser General Public
  14 // License along with this library; if not, write to the Free Software
  15 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  16 //
  17 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  18 //
  19
  20 #include "XGUI_ViewerProxy.h"
  21 #include "XGUI_Workshop.h"
  22 #include "XGUI_SalomeConnector.h"
  23 #include "XGUI_Displayer.h"
  24
  25 #ifndef HAVE_SALOME
  26   #include <AppElements_MainWindow.h>
  27   #include <AppElements_ViewPort.h>
  28   #include <AppElements_ViewWindow.h>
  29   #include <AppElements_Viewer.h>
  30 #endif
  31
  32 #include <ModuleBase_IViewWindow.h>
  33 #include <ModuleBase_Preferences.h>
  34 #include <GeomAPI_Shape.h>
  35 #include <ModelAPI_ResultConstruction.h>
  36
  37 #include <Config_PropManager.h>
  38
  39 #include <SUIT_ResourceMgr.h>
  40 #include <AIS_Shape.hxx>
  41 #include <StdSelect_BRepOwner.hxx>
  42
  43 #include <QEvent>
  44 #include <QKeyEvent>
  45
  46
  47 #define HIGHLIGHT_COLOR Quantity_NOC_YELLOW
  48
  49 XGUI_ViewerProxy::XGUI_ViewerProxy(XGUI_Workshop* theParent)
  50     : ModuleBase_IViewer(theParent),
  51       myWorkshop(theParent)
  52 {
  53 }
  54
  55 void XGUI_ViewerProxy::connectViewProxy()
  56 {
  57 #ifdef HAVE_SALOME
  58   connect(myWorkshop->salomeConnector()->viewer(), SIGNAL(trihedronVisibilityChanged(bool)),
  59          SIGNAL(trihedronVisibilityChanged(bool)));
  60 #else
  61   connect(myWorkshop->mainWindow()->viewer(), SIGNAL(trihedronVisibilityChanged(bool)),
  62          SIGNAL(trihedronVisibilityChanged(bool)));
  63 #endif
  64 }
  65
  66 Handle(AIS_InteractiveContext) XGUI_ViewerProxy::AISContext() const
  67 {
  68   Handle(AIS_InteractiveContext) aContext;
  69 #ifdef HAVE_SALOME
  70   aContext = myWorkshop->salomeConnector()->viewer()->AISContext();
  71 #else
  72   aContext = myWorkshop->mainWindow()->viewer()->AISContext();
  73 #endif
  74   return aContext;
  75 }
  76
  77 Handle(AIS_Trihedron) XGUI_ViewerProxy::trihedron() const
  78 {
  79 #ifdef HAVE_SALOME
  80   return myWorkshop->salomeConnector()->viewer()->trihedron();
  81 #else
  82   return myWorkshop->mainWindow()->viewer()->trihedron();
  83 #endif
  84 }
  85
  86 Handle(V3d_Viewer) XGUI_ViewerProxy::v3dViewer() const
  87 {
  88 #ifdef HAVE_SALOME
  89   return myWorkshop->salomeConnector()->viewer()->v3dViewer();
  90 #else
  91   return myWorkshop->mainWindow()->viewer()->v3dViewer();
  92 #endif
  93 }
  94
  95 Handle(V3d_View) XGUI_ViewerProxy::activeView() const
  96 {
  97 #ifdef HAVE_SALOME
  98   return myWorkshop->salomeConnector()->viewer()->activeView();
  99 #else
 100   AppElements_Viewer* aViewer = myWorkshop->mainWindow()->viewer();
 101   return (aViewer->activeViewWindow()) ?
 102     aViewer->activeViewWindow()->viewPortApp()->getView() :
 103     Handle(V3d_View)();
 104 #endif
 105 }
 106
 107 QWidget* XGUI_ViewerProxy::activeViewPort() const
 108 {
 109 #ifdef HAVE_SALOME
 110   return myWorkshop->salomeConnector()->viewer()->activeViewPort();
 111 #else
 112   AppElements_Viewer* aViewer = myWorkshop->mainWindow()->viewer();
 113   return (aViewer->activeViewWindow()) ?
 114          aViewer->activeViewWindow()->viewPortApp(): 0;
 115 #endif
 116 }
 117
 118 void XGUI_ViewerProxy::setViewProjection(double theX, double theY, double theZ, double theTwist)
 119 {
 120   Handle(V3d_View) aView3d = activeView();
 121   if (!aView3d.IsNull()) {
 122     aView3d->SetProj(theX, theY, theZ);
 123     aView3d->SetTwist( theTwist );
 124     aView3d->FitAll(0.01, false);
 125     aView3d->SetZSize(0.);
 126     if (aView3d->Depth() < 0.1)
 127       aView3d->DepthFitAll();
 128   }
 129 }
 130
 131 void XGUI_ViewerProxy::fitAll()
 132 {
 133 #ifdef HAVE_SALOME
 134   myWorkshop->salomeConnector()->viewer()->fitAll();
 135 #else
 136   AppElements_Viewer* aViewer = myWorkshop->mainWindow()->viewer();
 137   if (aViewer->activeViewWindow())
 138     aViewer->activeViewWindow()->viewPortApp()->fitAll();
 139 #endif
 140 }
 141
 142 void XGUI_ViewerProxy::eraseAll()
 143 {
 144 #ifdef HAVE_SALOME
 145   myWorkshop->salomeConnector()->viewer()->eraseAll();
 146 #else
 147 #endif
 148 }
 149
 150 void XGUI_ViewerProxy::connectToViewer()
 151 {
 152 #ifdef HAVE_SALOME
 153   ModuleBase_IViewer* aViewer = myWorkshop->salomeConnector()->viewer();
 154
 155   connect(aViewer, SIGNAL(lastViewClosed()), this, SIGNAL(lastViewClosed()));
 156   connect(aViewer, SIGNAL(tryCloseView(ModuleBase_IViewWindow*)),
 157     this, SIGNAL(tryCloseView(ModuleBase_IViewWindow*)));
 158
 159   connect(aViewer, SIGNAL(deleteView(ModuleBase_IViewWindow*)),
 160     this, SIGNAL(deleteView(ModuleBase_IViewWindow*)));
 161
 162   connect(aViewer, SIGNAL(viewCreated(ModuleBase_IViewWindow*)),
 163     this, SLOT(onViewCreated(ModuleBase_IViewWindow*)));
 164
 165   connect(aViewer, SIGNAL(activated(ModuleBase_IViewWindow*)),
 166     this, SIGNAL(activated(ModuleBase_IViewWindow*)));
 167
 168   connect(aViewer, SIGNAL(mousePress(ModuleBase_IViewWindow*, QMouseEvent*)),
 169     this, SIGNAL(mousePress(ModuleBase_IViewWindow*, QMouseEvent*)));
 170
 171   connect(aViewer, SIGNAL(mouseRelease(ModuleBase_IViewWindow*, QMouseEvent*)),
 172     this, SIGNAL(mouseRelease(ModuleBase_IViewWindow*, QMouseEvent*)));
 173
 174   connect(aViewer, SIGNAL(mouseDoubleClick(ModuleBase_IViewWindow*, QMouseEvent*)), this,
 175           SIGNAL(mouseDoubleClick(ModuleBase_IViewWindow*, QMouseEvent*)));
 176
 177   connect(aViewer, SIGNAL(mouseMove(ModuleBase_IViewWindow*, QMouseEvent*)),
 178     this, SLOT(onMouseMove(ModuleBase_IViewWindow*, QMouseEvent*)));
 179
 180   connect(aViewer, SIGNAL(keyPress(ModuleBase_IViewWindow*, QKeyEvent*)),
 181     this, SLOT(onKeyPress(ModuleBase_IViewWindow*, QKeyEvent*)));
 182
 183   connect(aViewer, SIGNAL(keyRelease(ModuleBase_IViewWindow*, QKeyEvent*)),
 184     this, SLOT(onKeyRelease(ModuleBase_IViewWindow*, QKeyEvent*)));
 185
 186   connect(aViewer, SIGNAL(selectionChanged()), this, SIGNAL(selectionChanged()));
 187
 188   connect(aViewer, SIGNAL(viewTransformed(int)), this, SIGNAL(viewTransformed(int)));
 189
 190   connect(aViewer, SIGNAL(contextMenuRequested(QContextMenuEvent*)), this,
 191           SIGNAL(contextMenuRequested(QContextMenuEvent*)));
 192
 193 #else
 194   AppElements_Viewer* aViewer = myWorkshop->mainWindow()->viewer();
 195
 196   connect(aViewer, SIGNAL(lastViewClosed()), this, SIGNAL(lastViewClosed()));
 197
 198   connect(aViewer, SIGNAL(tryCloseView(AppElements_ViewWindow*)),
 199           this, SLOT(onTryCloseView(AppElements_ViewWindow*)));
 200
 201   connect(aViewer, SIGNAL(deleteView(AppElements_ViewWindow*)),
 202           this, SLOT(onDeleteView(AppElements_ViewWindow*)));
 203
 204   connect(aViewer, SIGNAL(viewCreated(AppElements_ViewWindow*)),
 205           this, SLOT(onViewCreated(AppElements_ViewWindow*)));
 206
 207   connect(aViewer, SIGNAL(activated(AppElements_ViewWindow*)),
 208           this, SLOT(onActivated(AppElements_ViewWindow*)));
 209
 210   connect(aViewer, SIGNAL(mousePress(AppElements_ViewWindow*, QMouseEvent*)), this,
 211           SLOT(onMousePress(AppElements_ViewWindow*, QMouseEvent*)));
 212
 213   connect(aViewer, SIGNAL(mouseRelease(AppElements_ViewWindow*, QMouseEvent*)), this,
 214           SLOT(onMouseRelease(AppElements_ViewWindow*, QMouseEvent*)));
 215
 216   connect(aViewer, SIGNAL(mouseDoubleClick(AppElements_ViewWindow*, QMouseEvent*)), this,
 217           SLOT(onMouseDoubleClick(AppElements_ViewWindow*, QMouseEvent*)));
 218
 219   connect(aViewer, SIGNAL(mouseMove(AppElements_ViewWindow*, QMouseEvent*)), this,
 220           SLOT(onMouseMove(AppElements_ViewWindow*, QMouseEvent*)));
 221
 222   connect(aViewer, SIGNAL(keyPress(AppElements_ViewWindow*, QKeyEvent*)), this,
 223           SLOT(onKeyPress(AppElements_ViewWindow*, QKeyEvent*)));
 224
 225   connect(aViewer, SIGNAL(keyRelease(AppElements_ViewWindow*, QKeyEvent*)), this,
 226           SLOT(onKeyRelease(AppElements_ViewWindow*, QKeyEvent*)));
 227
 228   connect(aViewer, SIGNAL(selectionChanged()), this, SIGNAL(selectionChanged()));
 229   connect(aViewer, SIGNAL(contextMenuRequested(QContextMenuEvent*)), this,
 230           SIGNAL(contextMenuRequested(QContextMenuEvent*)));
 231 #endif
 232 }
 233
 234 bool XGUI_ViewerProxy::eventFilter(QObject *theObject, QEvent *theEvent)
 235 {
 236   if (theEvent->type() == QEvent::Enter) {
 237     emit enterViewPort();
 238   }
 239   else if (theEvent->type() == QEvent::Leave) {
 240     emit leaveViewPort();
 241   }
 242   return ModuleBase_IViewer::eventFilter(theObject, theEvent);
 243 }
 244
 245 void XGUI_ViewerProxy::onViewCreated(ModuleBase_IViewWindow* theWnd)
 246 {
 247   theWnd->viewPort()->installEventFilter(this);
 248   myWindowScale.insert (theWnd->v3dView(), theWnd->v3dView()->Camera()->Scale());
 249   emit viewCreated(theWnd);
 250 }
 251
 252 #ifndef HAVE_SALOME
 253 void XGUI_ViewerProxy::onTryCloseView(AppElements_ViewWindow* theWnd)
 254 {
 255   emit tryCloseView(theWnd);
 256 }
 257
 258 void XGUI_ViewerProxy::onDeleteView(AppElements_ViewWindow* theWnd)
 259 {
 260   if (myWindowScale.contains(theWnd->v3dView()))
 261     myWindowScale.remove (theWnd->v3dView());
 262   emit deleteView(theWnd);
 263 }
 264
 265 void XGUI_ViewerProxy::onViewCreated(AppElements_ViewWindow* theWnd)
 266 {
 267   theWnd->viewPort()->installEventFilter(this);
 268
 269   connect(theWnd, SIGNAL(vpTransformationFinished(AppElements_ViewWindow::OperationType)),
 270     this, SLOT(onViewTransformed(AppElements_ViewWindow::OperationType)));
 271
 272   myWindowScale.insert (theWnd->v3dView(), theWnd->v3dView()->Camera()->Scale());
 273
 274   emit viewCreated(theWnd);
 275 }
 276
 277 void XGUI_ViewerProxy::onActivated(AppElements_ViewWindow* theWnd)
 278 {
 279   emit activated(theWnd);
 280 }
 281
 282 void XGUI_ViewerProxy::onMousePress(AppElements_ViewWindow* theWnd, QMouseEvent* theEvent)
 283 {
 284   emit mousePress(theWnd, theEvent);
 285 }
 286
 287 void XGUI_ViewerProxy::onMouseRelease(AppElements_ViewWindow* theWnd, QMouseEvent* theEvent)
 288 {
 289   emit mouseRelease(theWnd, theEvent);
 290 }
 291
 292 void XGUI_ViewerProxy::onMouseDoubleClick(AppElements_ViewWindow* theWnd, QMouseEvent* theEvent)
 293 {
 294   emit mouseDoubleClick(theWnd, theEvent);
 295 }
 296
 297 void XGUI_ViewerProxy::onMouseMove(AppElements_ViewWindow* theWnd, QMouseEvent* theEvent)
 298 {
 299   if (myIs2dMode) {
 300     bool aHighlight2d =
 301       ModuleBase_Preferences::resourceMgr()->booleanValue("Viewer", "highlighting-2d", true);
 302     if (aHighlight2d) {
 303       if (myShowHighlight)
 304         eraseHighlight();
 305       else
 306         updateHighlight();
 307     }
 308     else {
 309       if (myShowHighlight)
 310         updateHighlight();
 311       else
 312         eraseHighlight();
 313     }
 314   }
 315   else {
 316     bool aHighlight3d =
 317       ModuleBase_Preferences::resourceMgr()->booleanValue("Viewer", "highlighting-3d", false);
 318     if (aHighlight3d) {
 319       if (myShowHighlight)
 320         eraseHighlight();
 321       else
 322         updateHighlight();
 323     }
 324     else {
 325       if (myShowHighlight)
 326         updateHighlight();
 327       else
 328         eraseHighlight();
 329     }
 330   }
 331   emit mouseMove(theWnd, theEvent);
 332 }
 333
 334 void XGUI_ViewerProxy::onKeyPress(AppElements_ViewWindow* theWnd, QKeyEvent* theEvent)
 335 {
 336   myShowHighlight = theEvent->key() == Qt::Key_H;
 337   emit keyPress(theWnd, theEvent);
 338 }
 339
 340 void XGUI_ViewerProxy::onKeyRelease(AppElements_ViewWindow* theWnd, QKeyEvent* theEvent)
 341 {
 342   if (theEvent->key() == Qt::Key_H) {
 343     myShowHighlight = false;
 344   }
 345   emit keyRelease(theWnd, theEvent);
 346 }
 347
 348 void XGUI_ViewerProxy::onViewTransformed(AppElements_ViewWindow::OperationType theType)
 349 {
 350   emit viewTransformed((int) theType);
 351 }
 352
 353 #endif
 354
 355
 356 //***************************************
 357 void XGUI_ViewerProxy::enableSelection(bool isEnabled)
 358 {
 359 #ifdef HAVE_SALOME
 360   myWorkshop->salomeConnector()->viewer()->enableSelection(isEnabled);
 361 #else
 362   myWorkshop->mainWindow()->viewer()->setSelectionEnabled(isEnabled);
 363 #endif
 364 }
 365
 366 //***************************************
 367 bool XGUI_ViewerProxy::isSelectionEnabled() const
 368 {
 369 #ifdef HAVE_SALOME
 370   return myWorkshop->salomeConnector()->viewer()->isSelectionEnabled();
 371 #else
 372   return myWorkshop->mainWindow()->viewer()->isSelectionEnabled();
 373 #endif
 374 }
 375
 376 //***************************************
 377 void XGUI_ViewerProxy::enableMultiselection(bool isEnable)
 378 {
 379 #ifdef HAVE_SALOME
 380   myWorkshop->salomeConnector()->viewer()->enableMultiselection(isEnable);
 381 #else
 382   myWorkshop->mainWindow()->viewer()->setMultiSelectionEnabled(isEnable);
 383 #endif
 384 }
 385
 386 //***************************************
 387 bool XGUI_ViewerProxy::isMultiSelectionEnabled() const
 388 {
 389 #ifdef HAVE_SALOME
 390   return myWorkshop->salomeConnector()->viewer()->isMultiSelectionEnabled();
 391 #else
 392   return myWorkshop->mainWindow()->viewer()->isMultiSelectionEnabled();
 393 #endif
 394 }
 395
 396 //***************************************
 397 bool XGUI_ViewerProxy::enableDrawMode(bool isEnabled)
 398 {
 399 #ifdef HAVE_SALOME
 400   return myWorkshop->salomeConnector()->viewer()->enableDrawMode(isEnabled);
 401 #else
 402   return myWorkshop->mainWindow()->viewer()->enableDrawMode(isEnabled);
 403 #endif
 404 }
 405
 406 //***************************************
 407 void XGUI_ViewerProxy::addSelectionFilter(const Handle(SelectMgr_Filter)& theFilter)
 408 {
 409   myWorkshop->displayer()->addSelectionFilter(theFilter);
 410 }
 411
 412 //***************************************
 413 void XGUI_ViewerProxy::removeSelectionFilter(const Handle(SelectMgr_Filter)& theFilter)
 414 {
 415   myWorkshop->displayer()->removeSelectionFilter(theFilter);
 416 }
 417
 418 //***************************************
 419 bool XGUI_ViewerProxy::hasSelectionFilter(const Handle(SelectMgr_Filter)& theFilter)
 420 {
 421   return myWorkshop->displayer()->hasSelectionFilter(theFilter);
 422 }
 423
 424 //***************************************
 425 void XGUI_ViewerProxy::clearSelectionFilters()
 426 {
 427   myWorkshop->displayer()->removeFilters();
 428 }
 429
 430 //***************************************
 431 void XGUI_ViewerProxy::update()
 432 {
 433   myWorkshop->displayer()->updateViewer();
 434 }
 435
 436 //***************************************
 437 bool XGUI_ViewerProxy::canDragByMouse() const
 438 {
 439   if (myWorkshop->isSalomeMode()) {
 440     ModuleBase_IViewer* aViewer = myWorkshop->salomeConnector()->viewer();
 441     return aViewer->canDragByMouse();
 442   } else {
 443     return true;
 444   }
 445 }
 446
 447 //***************************************
 448 void XGUI_ViewerProxy::displayHighlight(FeaturePtr theFeature, const TopoDS_Shape& theIgnoreShape)
 449 {
 450   Handle(AIS_InteractiveContext) aContext = AISContext();
 451
 452   double aDeflection;
 453   if (myResult->groupName() == ModelAPI_ResultConstruction::group()) {
 454     //FeaturePtr aFeature = ModelAPI_Feature::feature(myResult);
 455     if (theFeature.get()) {
 456       std::list<ResultPtr> aResults = theFeature->results();
 457       std::list<ResultPtr>::const_iterator aIt;
 458       ResultPtr aRes;
 459       Handle(AIS_Shape) aAis;
 460       for (aIt = aResults.cbegin(); aIt != aResults.cend(); aIt++) {
 461         aRes = (*aIt);
 462         TopoDS_Shape aTShape = aRes->shape()->impl<TopoDS_Shape>();
 463         if (!aTShape.IsSame(theIgnoreShape)) {
 464           aAis = new AIS_Shape(aTShape);
 465           aAis->SetColor(HIGHLIGHT_COLOR);
 466           aAis->SetZLayer(Graphic3d_ZLayerId_Top); //Graphic3d_ZLayerId_Topmost
 467           aDeflection = Config_PropManager::real("Visualization", "construction_deflection");
 468           aAis->Attributes()->SetDeviationCoefficient(aDeflection);
 469           myHighlights.Append(aAis);
 470           aContext->Display(aAis, false);
 471           aContext->Deactivate(aAis);
 472         }
 473       }
 474     }
 475   }
 476   else {
 477     TopoDS_Shape aTShape = myResult->shape()->impl<TopoDS_Shape>();
 478     Handle(AIS_Shape) aAis = new AIS_Shape(aTShape);
 479     aAis->SetColor(HIGHLIGHT_COLOR);
 480     aAis->SetZLayer(Graphic3d_ZLayerId_Top); //Graphic3d_ZLayerId_Topmost
 481     aDeflection = Config_PropManager::real("Visualization", "body_deflection");
 482     aAis->Attributes()->SetDeviationCoefficient(aDeflection);
 483     myHighlights.Append(aAis);
 484     aContext->Display(aAis, false);
 485     aContext->Deactivate(aAis);
 486   }
 487 }
 488
 489 void XGUI_ViewerProxy::eraseHighlight()
 490 {
 491   Handle(AIS_InteractiveContext) aContext = AISContext();
 492   Handle(AIS_InteractiveObject) anAISIO;
 493   AIS_ListIteratorOfListOfInteractive aLIt;
 494   for (aLIt.Initialize(myHighlights); aLIt.More(); aLIt.Next()) {
 495     anAISIO = aLIt.Value();
 496     aContext->Remove(anAISIO, false);
 497   }
 498   myHighlights.Clear();
 499 }
 500
 501 void XGUI_ViewerProxy::updateHighlight()
 502 {
 503   Handle(AIS_InteractiveContext) aContext = AISContext();
 504   if (!aContext.IsNull()) {
 505     Handle(StdSelect_BRepOwner) aOwner;
 506     Handle(AIS_InteractiveObject) anIO;
 507     bool isDisplayed = false;
 508     TopoDS_Shape aShape, aShp;
 509     ResultPtr aRes;
 510     XGUI_Displayer* aDisplayer = myWorkshop->displayer();
 511     for (aContext->InitDetected(); aContext->MoreDetected(); aContext->NextDetected()) {
 512       aOwner = Handle(StdSelect_BRepOwner)::DownCast(aContext->DetectedOwner());
 513       if ((!aOwner.IsNull()) && aOwner->HasShape()) {
 514         aShape = aOwner->Shape();
 515         anIO = Handle(AIS_InteractiveObject)::DownCast(aOwner->Selectable());
 516         aRes = std::dynamic_pointer_cast<ModelAPI_Result>(aDisplayer->getObject(anIO));
 517         if (aRes.get() && (aRes != myResult)) {
 518           eraseHighlight();
 519           FeaturePtr aFeature = ModelAPI_Feature::feature(aRes);
 520           aShp = aRes->shape()->impl<TopoDS_Shape>();
 521           if ((aFeature->results().size() > 1) || (!aShp.IsSame(aShape))) {
 522             myResult = aRes;
 523             displayHighlight(aFeature, aShape);
 524           }
 525           else {
 526             myResult = ResultPtr();
 527           }
 528           aContext->UpdateCurrentViewer();
 529         }
 530         isDisplayed = aRes.get();
 531       }
 532     }
 533     if (!isDisplayed) {
 534       eraseHighlight();
 535       aContext->UpdateCurrentViewer();
 536       myResult = ResultPtr();
 537     }
 538   }
 539 }
 540
 541 #ifdef HAVE_SALOME
 542 void XGUI_ViewerProxy::onMouseMove(ModuleBase_IViewWindow* theWnd, QMouseEvent* theEvent)
 543 {
 544   if (myIs2dMode) {
 545     bool aHighlight2d =
 546       ModuleBase_Preferences::resourceMgr()->booleanValue("Viewer", "highlighting-2d", true);
 547     if (aHighlight2d) {
 548       if (myShowHighlight)
 549         eraseHighlight();
 550       else
 551         updateHighlight();
 552     }
 553     else {
 554       if (myShowHighlight)
 555         updateHighlight();
 556       else
 557         eraseHighlight();
 558     }
 559   }
 560   else {
 561     bool aHighlight3d =
 562       ModuleBase_Preferences::resourceMgr()->booleanValue("Viewer", "highlighting-3d", false);
 563     if (aHighlight3d) {
 564       if (myShowHighlight)
 565         eraseHighlight();
 566       else
 567         updateHighlight();
 568     }
 569     else {
 570       if (myShowHighlight)
 571         updateHighlight();
 572       else
 573         eraseHighlight();
 574     }
 575   }
 576   emit mouseMove(theWnd, theEvent);
 577 }
 578
 579 void XGUI_ViewerProxy::onKeyPress(ModuleBase_IViewWindow* theWnd, QKeyEvent* theEvent)
 580 {
 581   myShowHighlight = theEvent->key() == Qt::Key_H;
 582   emit keyPress(theWnd, theEvent);
 583 }
 584
 585 void XGUI_ViewerProxy::onKeyRelease(ModuleBase_IViewWindow* theWnd, QKeyEvent* theEvent)
 586 {
 587   if (theEvent->key() == Qt::Key_H) {
 588     myShowHighlight = false;
 589   }
 590   emit keyRelease(theWnd, theEvent);
 591 }
 592 #endif
 593
 594
 595 bool XGUI_ViewerProxy::isColorScaleVisible() const
 596 {
 597 #ifdef HAVE_SALOME
 598   return myWorkshop->salomeConnector()->viewer()->isColorScaleVisible();
 599 #else
 600   return myWorkshop->mainWindow()->viewer()->isColorScaleVisible();
 601 #endif
 602 }
 603
 604 void XGUI_ViewerProxy::setColorScaleShown(bool on)
 605 {
 606 #ifdef HAVE_SALOME
 607   myWorkshop->salomeConnector()->viewer()->setColorScaleShown(on);
 608 #else
 609   myWorkshop->mainWindow()->viewer()->setColorScaleShown(on);
 610 #endif
 611 }
 612
 613 void XGUI_ViewerProxy::setColorScalePosition(double theX, double theY)
 614 {
 615 #ifdef HAVE_SALOME
 616   myWorkshop->salomeConnector()->viewer()->setColorScalePosition(theX, theY);
 617 #else
 618   QWidget* aWindow = activeViewPort();
 619   Handle(AIS_ColorScale) aColorScale = myWorkshop->mainWindow()->viewer()->colorScale();
 620   aColorScale->SetPosition(aWindow->width() * theX, aWindow->height() * theY);
 621 #endif
 622 }
 623
 624 void XGUI_ViewerProxy::setColorScaleSize(double theW, double theH)
 625 {
 626 #ifdef HAVE_SALOME
 627   myWorkshop->salomeConnector()->viewer()->setColorScaleSize(theW, theH);
 628 #else
 629   QWidget* aWindow = activeViewPort();
 630   Handle(AIS_ColorScale) aColorScale = myWorkshop->mainWindow()->viewer()->colorScale();
 631   aColorScale->SetSize(aWindow->width() * theW, aWindow->height() * theH);
 632 #endif
 633 }
 634
 635 void XGUI_ViewerProxy::setColorScaleRange(double theMin, double theMax)
 636 {
 637 #ifdef HAVE_SALOME
 638   myWorkshop->salomeConnector()->viewer()->setColorScaleRange(theMin, theMax);
 639 #else
 640   Handle(AIS_ColorScale) aColorScale = myWorkshop->mainWindow()->viewer()->colorScale();
 641   aColorScale->SetRange(theMin, theMax);
 642 #endif
 643 }
 644
 645 void XGUI_ViewerProxy::setColorScaleIntervals(int theNb)
 646 {
 647 #ifdef HAVE_SALOME
 648   myWorkshop->salomeConnector()->viewer()->setColorScaleIntervals(theNb);
 649 #else
 650   Handle(AIS_ColorScale) aColorScale = myWorkshop->mainWindow()->viewer()->colorScale();
 651   aColorScale->SetNumberOfIntervals(theNb);
 652 #endif
 653 }
 654
 655 void XGUI_ViewerProxy::setColorScaleTextColor(const QColor& theColor)
 656 {
 657 #ifdef HAVE_SALOME
 658   myWorkshop->salomeConnector()->viewer()->setColorScaleTextColor(theColor);
 659 #else
 660   Handle(AIS_ColorScale) aColorScale = myWorkshop->mainWindow()->viewer()->colorScale();
 661   Quantity_Color aColor(theColor.redF(), theColor.greenF(), theColor.blueF(), Quantity_TOC_RGB);
 662   aColorScale->SetColor(aColor);
 663 #endif
 664 }
 665
 666
 667 void XGUI_ViewerProxy::setColorScaleTextHeigth(int theH)
 668 {
 669 #ifdef HAVE_SALOME
 670   myWorkshop->salomeConnector()->viewer()->setColorScaleTextHeigth(theH);
 671 #else
 672   Handle(AIS_ColorScale) aColorScale = myWorkshop->mainWindow()->viewer()->colorScale();
 673   aColorScale->SetTextHeight(theH);
 674 #endif
 675 }
 676
 677 void XGUI_ViewerProxy::setColorScaleTitle(const QString& theText)
 678 {
 679 #ifdef HAVE_SALOME
 680   myWorkshop->salomeConnector()->viewer()->setColorScaleTitle(theText);
 681 #else
 682   Handle(AIS_ColorScale) aColorScale = myWorkshop->mainWindow()->viewer()->colorScale();
 683   aColorScale->SetTitle(theText.toStdString().c_str());
 684 #endif
 685 }
 686
 687
 688 //******************************************************
 689 void XGUI_ViewerProxy::setupColorScale()
 690 {
 691   SUIT_ResourceMgr* aResMgr = ModuleBase_Preferences::resourceMgr();
 692   double aX = aResMgr->doubleValue("Viewer", "scalar_bar_x_position", 0.03);
 693   double aY = aResMgr->doubleValue("Viewer", "scalar_bar_y_position", 0.35);
 694   setColorScalePosition(aX, aY);
 695
 696   double aW = aResMgr->doubleValue("Viewer", "scalar_bar_width", 0.2);
 697   double aH = aResMgr->doubleValue("Viewer", "scalar_bar_height", 0.5);
 698   setColorScaleSize(aW, aH);
 699
 700   QColor aColor = aResMgr->colorValue("Viewer", "scalar_bar_text_color", Qt::black);
 701   setColorScaleTextColor(aColor);
 702
 703   int aT = aResMgr->integerValue("Viewer", "scalar_bar_text_height", 14);
 704   setColorScaleTextHeigth(aT);
 705
 706   int aN = aResMgr->integerValue("Viewer", "scalar_bar_nb_intervals", 20);
 707   setColorScaleIntervals(aN);
 708 }
 709
 710
 711 //***************************************
 712 //void XGUI_ViewerProxy::Zfitall()
 713 //{
 714 //#ifdef HAVE_SALOME
 715 //  myWorkshop->salomeConnector()->viewer()->Zfitall();
 716 //#else
 717 //  AppElements_Viewer* aViewer = myWorkshop->mainWindow()->viewer();
 718 //  AppElements_ViewWindow* aView = aViewer->activeViewWindow();
 719 //  if (aView) {
 720 //    Handle(V3d_View) aView3d = aView->v3dView();
 721 //    aView3d->ZFitAll();
 722 //    if (aView3d->Depth() < 0.1)
 723 //      aView3d->DepthFitAll();
 724 //  }
 725 //#endif
 726 //}
 727
 728
 729 #ifdef HAVE_SALOME
 730 void XGUI_ViewerProxy::setFitter(OCCViewer_Fitter* theFitter)
 731 {
 732   myWorkshop->salomeConnector()->viewer()->setFitter(theFitter);
 733 }
 734
 735 OCCViewer_Fitter* XGUI_ViewerProxy::currentFitter() const
 736 {
 737   return myWorkshop->salomeConnector()->viewer()->currentFitter();
 738 }
 739 #else
 740 void XGUI_ViewerProxy::setFitter(AppElements_Fitter* theFitter)
 741 {
 742   myWorkshop->mainWindow()->viewer()->setFitter(theFitter);
 743 }
 744
 745 AppElements_Fitter* XGUI_ViewerProxy::currentFitter() const
 746 {
 747   return myWorkshop->mainWindow()->viewer()->currentFitter();
 748 }
 749 #endif
 750
 751 void XGUI_ViewerProxy::unsetFitter()
 752 {
 753 #ifdef HAVE_SALOME
 754   myWorkshop->salomeConnector()->viewer()->unsetFitter();
 755 #else
 756   myWorkshop->mainWindow()->viewer()->unsetFitter();
 757 #endif
 758 }