diff --git a/Modules/QtWidgets/src/QmitkRenderWindow.cpp b/Modules/QtWidgets/src/QmitkRenderWindow.cpp
index ac15146160..ab9657b238 100644
--- a/Modules/QtWidgets/src/QmitkRenderWindow.cpp
+++ b/Modules/QtWidgets/src/QmitkRenderWindow.cpp
@@ -1,516 +1,516 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include "QmitkRenderWindow.h"
#include "mitkInteractionKeyEvent.h"
#include "mitkInternalEvent.h"
#include "mitkMouseDoubleClickEvent.h"
#include "mitkMouseMoveEvent.h"
#include "mitkMousePressEvent.h"
#include "mitkMouseReleaseEvent.h"
#include "mitkMouseWheelEvent.h"
#include <mitkStatusBar.h>
#include <QCursor>
#include <QDragEnterEvent>
#include <QDropEvent>
#include <QKeyEvent>
#include <QMouseEvent>
#include <QResizeEvent>
#include <QSurfaceFormat>
#include <QTimer>
#include <QWheelEvent>
#include <QWindow>
#include <QmitkMimeTypes.h>
#include <QmitkRenderWindowMenu.h>
#include <QmitkStyleManager.h>
QmitkRenderWindow::QmitkRenderWindow(QWidget *parent, const QString &name, mitk::VtkPropRenderer *)
: QVTKOpenGLNativeWidget(parent)
, m_ResendQtEvents(true)
, m_MenuWidget(nullptr)
, m_MenuWidgetActivated(false)
, m_LayoutIndex(QmitkRenderWindowMenu::LayoutIndex::Axial)
, m_GeometryViolationWarningOverlay(nullptr)
{
m_InternalRenderWindow = vtkSmartPointer<vtkGenericOpenGLRenderWindow>::New();
m_InternalRenderWindow->SetMultiSamples(0);
m_InternalRenderWindow->SetAlphaBitPlanes(0);
setRenderWindow(m_InternalRenderWindow);
Initialize(name.toStdString().c_str());
setFocusPolicy(Qt::StrongFocus);
setMouseTracking(true);
QSizePolicy sizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
setSizePolicy(sizePolicy);
// setup overlay widget to show a warning message with a button
m_GeometryViolationWarningOverlay = new QmitkButtonOverlayWidget(this);
m_GeometryViolationWarningOverlay->setVisible(false);
m_GeometryViolationWarningOverlay->SetOverlayText(
QStringLiteral("<font color=\"red\"><p style=\"text-align:center\">Interaction is not possible because the "
"render window geometry<br>does not match the interaction reference geometry.</p></center></font>"));
m_GeometryViolationWarningOverlay->SetButtonText("Reset geometry");
m_GeometryViolationWarningOverlay->SetButtonIcon(QmitkStyleManager::ThemeIcon(QLatin1String(":/Qmitk/reset.svg")));
connect(m_GeometryViolationWarningOverlay, &QmitkButtonOverlayWidget::Clicked,
this, &QmitkRenderWindow::ResetGeometry);
}
QmitkRenderWindow::~QmitkRenderWindow()
{
Destroy(); // Destroy mitkRenderWindowBase
}
void QmitkRenderWindow::SetResendQtEvents(bool resend)
{
m_ResendQtEvents = resend;
}
void QmitkRenderWindow::SetLayoutIndex(QmitkRenderWindowMenu::LayoutIndex layoutIndex)
{
m_LayoutIndex = layoutIndex;
if (nullptr != m_MenuWidget)
{
m_MenuWidget->SetLayoutIndex(layoutIndex);
}
}
QmitkRenderWindowMenu::LayoutIndex QmitkRenderWindow::GetLayoutIndex()
{
if (nullptr != m_MenuWidget)
{
return m_MenuWidget->GetLayoutIndex();
}
else
{
return QmitkRenderWindowMenu::LayoutIndex::Axial;
}
}
void QmitkRenderWindow::UpdateLayoutDesignList(QmitkRenderWindowMenu::LayoutDesign layoutDesign)
{
if (nullptr != m_MenuWidget)
{
m_MenuWidget->UpdateLayoutDesignList(layoutDesign);
}
}
void QmitkRenderWindow::UpdateCrosshairVisibility(bool visible)
{
m_MenuWidget->UpdateCrosshairVisibility(visible);
}
void QmitkRenderWindow::UpdateCrosshairRotationMode(int mode)
{
m_MenuWidget->UpdateCrosshairRotationMode(mode);
}
void QmitkRenderWindow::ActivateMenuWidget(bool state)
{
if (nullptr == m_MenuWidget)
{
m_MenuWidget = new QmitkRenderWindowMenu(this, {}, m_Renderer);
m_MenuWidget->SetLayoutIndex(m_LayoutIndex);
}
if (m_MenuWidgetActivated == state)
{
// no new state; nothing to do
return;
}
m_MenuWidgetActivated = state;
if (m_MenuWidgetActivated)
{
connect(m_MenuWidget, &QmitkRenderWindowMenu::LayoutDesignChanged, this, &QmitkRenderWindow::LayoutDesignChanged);
connect(m_MenuWidget, &QmitkRenderWindowMenu::ResetView, this, &QmitkRenderWindow::ResetView);
connect(m_MenuWidget, &QmitkRenderWindowMenu::CrosshairVisibilityChanged, this, &QmitkRenderWindow::CrosshairVisibilityChanged);
connect(m_MenuWidget, &QmitkRenderWindowMenu::CrosshairRotationModeChanged, this, &QmitkRenderWindow::CrosshairRotationModeChanged);
}
else
{
disconnect(m_MenuWidget, &QmitkRenderWindowMenu::LayoutDesignChanged, this, &QmitkRenderWindow::LayoutDesignChanged);
disconnect(m_MenuWidget, &QmitkRenderWindowMenu::ResetView, this, &QmitkRenderWindow::ResetView);
disconnect(m_MenuWidget, &QmitkRenderWindowMenu::CrosshairVisibilityChanged, this, &QmitkRenderWindow::CrosshairVisibilityChanged);
disconnect(m_MenuWidget, &QmitkRenderWindowMenu::CrosshairRotationModeChanged, this, &QmitkRenderWindow::CrosshairRotationModeChanged);
m_MenuWidget->hide();
}
}
void QmitkRenderWindow::ShowOverlayMessage(bool show)
{
m_GeometryViolationWarningOverlay->setVisible(show);
}
void QmitkRenderWindow::moveEvent(QMoveEvent *event)
{
QVTKOpenGLNativeWidget::moveEvent(event);
// after a move the overlays need to be positioned
emit moved();
}
void QmitkRenderWindow::showEvent(QShowEvent *event)
{
QVTKOpenGLNativeWidget::showEvent(event);
// this singleshot is necessary to have the overlays positioned correctly after initial show
// simple call of moved() is no use here!!
QTimer::singleShot(0, this, SIGNAL(moved()));
}
bool QmitkRenderWindow::event(QEvent* e)
{
mitk::InteractionEvent::Pointer mitkEvent = nullptr;
mitk::Point2D mousePosition;
bool updateStatusBar = false;
switch (e->type())
{
case QEvent::MouseMove:
{
auto me = static_cast<QMouseEvent *>(e);
mousePosition = this->GetMousePosition(me);
mitkEvent = mitk::MouseMoveEvent::New(m_Renderer, mousePosition, GetButtonState(me), GetModifiers(me));
updateStatusBar = true;
break;
}
case QEvent::MouseButtonPress:
{
auto me = static_cast<QMouseEvent *>(e);
mitkEvent = mitk::MousePressEvent::New( m_Renderer, GetMousePosition(me), GetButtonState(me), GetModifiers(me), GetEventButton(me));
break;
}
case QEvent::MouseButtonRelease:
{
auto me = static_cast<QMouseEvent *>(e);
mitkEvent = mitk::MouseReleaseEvent::New( m_Renderer, GetMousePosition(me), GetButtonState(me), GetModifiers(me), GetEventButton(me));
break;
}
case QEvent::MouseButtonDblClick:
{
auto me = static_cast<QMouseEvent *>(e);
mitkEvent = mitk::MouseDoubleClickEvent::New( m_Renderer, GetMousePosition(me), GetButtonState(me), GetModifiers(me), GetEventButton(me));
break;
}
case QEvent::Wheel:
{
auto we = static_cast<QWheelEvent *>(e);
mousePosition = this->GetMousePosition(we);
mitkEvent = mitk::MouseWheelEvent::New(m_Renderer, mousePosition, GetButtonState(we), GetModifiers(we), GetDelta(we));
updateStatusBar = true;
break;
}
case QEvent::KeyPress:
{
auto ke = static_cast<QKeyEvent*>(e);
mitkEvent = mitk::InteractionKeyEvent::New(m_Renderer, GetKeyLetter(ke), GetModifiers(ke));
break;
}
case QEvent::Resize:
{
if (nullptr != m_MenuWidget)
m_MenuWidget->MoveWidgetToCorrectPos();
}
default:
{
break;
}
}
if (mitkEvent != nullptr)
{
if (this->HandleEvent(mitkEvent.GetPointer())) {
return m_ResendQtEvents ? false : true;
}
}
if (updateStatusBar)
{
this->UpdateStatusBar(mousePosition);
}
return QVTKOpenGLNativeWidget::event(e);
}
void QmitkRenderWindow::enterEvent(QEnterEvent *e)
{
auto* baseRenderer = mitk::BaseRenderer::GetInstance(this->GetVtkRenderWindow());
this->ShowOverlayMessage(!baseRenderer->GetReferenceGeometryAligned());
if (nullptr != m_MenuWidget)
m_MenuWidget->ShowMenu();
QVTKOpenGLNativeWidget::enterEvent(e);
}
void QmitkRenderWindow::leaveEvent(QEvent *e)
{
auto statusBar = mitk::StatusBar::GetInstance();
statusBar->DisplayGreyValueText("");
this->ShowOverlayMessage(false);
if (nullptr != m_MenuWidget)
m_MenuWidget->HideMenu();
QVTKOpenGLNativeWidget::leaveEvent(e);
}
void QmitkRenderWindow::resizeGL(int w, int h)
{
QVTKOpenGLNativeWidget::resizeGL(w, h);
mitk::RenderingManager::GetInstance()->ForceImmediateUpdate(renderWindow());
}
void QmitkRenderWindow::dragEnterEvent(QDragEnterEvent *event)
{
if (event->mimeData()->hasFormat("application/x-mitk-datanodes"))
{
event->accept();
}
}
void QmitkRenderWindow::dropEvent(QDropEvent *event)
{
QList<mitk::DataNode *> dataNodeList = QmitkMimeTypes::ToDataNodePtrList(event->mimeData());
if (!dataNodeList.empty())
{
std::vector dataNodes(dataNodeList.begin(), dataNodeList.end());
emit NodesDropped(this, dataNodes);
}
}
void QmitkRenderWindow::DeferredHideMenu()
{
MITK_DEBUG << "QmitkRenderWindow::DeferredHideMenu";
if (nullptr != m_MenuWidget)
{
m_MenuWidget->HideMenu();
}
}
mitk::Point2D QmitkRenderWindow::GetMousePosition(QMouseEvent *me) const
{
mitk::Point2D point;
const auto scale = this->devicePixelRatioF();
point[0] = me->x()*scale;
// We need to convert the y component, as the display and vtk have other definitions for the y direction
point[1] = m_Renderer->GetSizeY() - me->y()*scale;
return point;
}
mitk::Point2D QmitkRenderWindow::GetMousePosition(QWheelEvent *we) const
{
mitk::Point2D point;
const auto scale = this->devicePixelRatioF();
- point[0] = we->x()*scale;
+ point[0] = we->position().x()*scale;
// We need to convert the y component, as the display and vtk have other definitions for the y direction
- point[1] = m_Renderer->GetSizeY() - we->y()*scale;
+ point[1] = m_Renderer->GetSizeY() - we->position().y()*scale;
return point;
}
mitk::InteractionEvent::MouseButtons QmitkRenderWindow::GetEventButton(QMouseEvent *me) const
{
mitk::InteractionEvent::MouseButtons eventButton;
switch (me->button())
{
case Qt::LeftButton:
eventButton = mitk::InteractionEvent::LeftMouseButton;
break;
case Qt::RightButton:
eventButton = mitk::InteractionEvent::RightMouseButton;
break;
case Qt::MiddleButton:
eventButton = mitk::InteractionEvent::MiddleMouseButton;
break;
default:
eventButton = mitk::InteractionEvent::NoButton;
break;
}
return eventButton;
}
mitk::InteractionEvent::MouseButtons QmitkRenderWindow::GetButtonState(QMouseEvent *me) const
{
mitk::InteractionEvent::MouseButtons buttonState = mitk::InteractionEvent::NoButton;
if (me->buttons() & Qt::LeftButton)
{
buttonState = buttonState | mitk::InteractionEvent::LeftMouseButton;
}
if (me->buttons() & Qt::RightButton)
{
buttonState = buttonState | mitk::InteractionEvent::RightMouseButton;
}
if (me->buttons() & Qt::MiddleButton)
{
buttonState = buttonState | mitk::InteractionEvent::MiddleMouseButton;
}
return buttonState;
}
mitk::InteractionEvent::ModifierKeys QmitkRenderWindow::GetModifiers(QInputEvent *me) const
{
mitk::InteractionEvent::ModifierKeys modifiers = mitk::InteractionEvent::NoKey;
if (me->modifiers() & Qt::ALT)
{
modifiers = modifiers | mitk::InteractionEvent::AltKey;
}
if (me->modifiers() & Qt::CTRL)
{
modifiers = modifiers | mitk::InteractionEvent::ControlKey;
}
if (me->modifiers() & Qt::SHIFT)
{
modifiers = modifiers | mitk::InteractionEvent::ShiftKey;
}
return modifiers;
}
mitk::InteractionEvent::MouseButtons QmitkRenderWindow::GetButtonState(QWheelEvent *we) const
{
mitk::InteractionEvent::MouseButtons buttonState = mitk::InteractionEvent::NoButton;
if (we->buttons() & Qt::LeftButton)
{
buttonState = buttonState | mitk::InteractionEvent::LeftMouseButton;
}
if (we->buttons() & Qt::RightButton)
{
buttonState = buttonState | mitk::InteractionEvent::RightMouseButton;
}
if (we->buttons() & Qt::MiddleButton)
{
buttonState = buttonState | mitk::InteractionEvent::MiddleMouseButton;
}
return buttonState;
}
std::string QmitkRenderWindow::GetKeyLetter(QKeyEvent *ke) const
{
// Converting Qt Key Event to string element.
std::string key = "";
int tkey = ke->key();
if (tkey < 128)
{ // standard ascii letter
key = (char)toupper(tkey);
}
else
{ // special keys
switch (tkey)
{
case Qt::Key_Return:
key = mitk::InteractionEvent::KeyReturn;
break;
case Qt::Key_Enter:
key = mitk::InteractionEvent::KeyEnter;
break;
case Qt::Key_Escape:
key = mitk::InteractionEvent::KeyEsc;
break;
case Qt::Key_Delete:
key = mitk::InteractionEvent::KeyDelete;
break;
case Qt::Key_Up:
key = mitk::InteractionEvent::KeyArrowUp;
break;
case Qt::Key_Down:
key = mitk::InteractionEvent::KeyArrowDown;
break;
case Qt::Key_Left:
key = mitk::InteractionEvent::KeyArrowLeft;
break;
case Qt::Key_Right:
key = mitk::InteractionEvent::KeyArrowRight;
break;
case Qt::Key_F1:
key = mitk::InteractionEvent::KeyF1;
break;
case Qt::Key_F2:
key = mitk::InteractionEvent::KeyF2;
break;
case Qt::Key_F3:
key = mitk::InteractionEvent::KeyF3;
break;
case Qt::Key_F4:
key = mitk::InteractionEvent::KeyF4;
break;
case Qt::Key_F5:
key = mitk::InteractionEvent::KeyF5;
break;
case Qt::Key_F6:
key = mitk::InteractionEvent::KeyF6;
break;
case Qt::Key_F7:
key = mitk::InteractionEvent::KeyF7;
break;
case Qt::Key_F8:
key = mitk::InteractionEvent::KeyF8;
break;
case Qt::Key_F9:
key = mitk::InteractionEvent::KeyF9;
break;
case Qt::Key_F10:
key = mitk::InteractionEvent::KeyF10;
break;
case Qt::Key_F11:
key = mitk::InteractionEvent::KeyF11;
break;
case Qt::Key_F12:
key = mitk::InteractionEvent::KeyF12;
break;
case Qt::Key_End:
key = mitk::InteractionEvent::KeyEnd;
break;
case Qt::Key_Home:
key = mitk::InteractionEvent::KeyPos1;
break;
case Qt::Key_Insert:
key = mitk::InteractionEvent::KeyInsert;
break;
case Qt::Key_PageDown:
key = mitk::InteractionEvent::KeyPageDown;
break;
case Qt::Key_PageUp:
key = mitk::InteractionEvent::KeyPageUp;
break;
case Qt::Key_Space:
key = mitk::InteractionEvent::KeySpace;
break;
}
}
return key;
}
int QmitkRenderWindow::GetDelta(QWheelEvent *we) const
{
- return we->delta();
+ return we->angleDelta().y();
}
void QmitkRenderWindow::UpdateStatusBar(mitk::Point2D pointerPositionOnScreen)
{
mitk::Point3D worldPosition;
m_Renderer->ForceImmediateUpdate();
m_Renderer->DisplayToWorld(pointerPositionOnScreen, worldPosition);
auto statusBar = mitk::StatusBar::GetInstance();
statusBar->DisplayRendererInfo(worldPosition, m_Renderer->GetTime());
}
diff --git a/Modules/QtWidgetsExt/src/QmitkPointListView.cpp b/Modules/QtWidgetsExt/src/QmitkPointListView.cpp
index cf25972d78..3d3ec8c652 100644
--- a/Modules/QtWidgetsExt/src/QmitkPointListView.cpp
+++ b/Modules/QtWidgetsExt/src/QmitkPointListView.cpp
@@ -1,336 +1,336 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include "QmitkPointListView.h"
#include <QmitkEditPointDialog.h>
#include <QmitkPointListModel.h>
#include <QmitkRenderWindow.h>
#include <QmitkAbstractMultiWidget.h>
#include <mitkRenderingManager.h>
#include <QKeyEvent>
#include <QMenu>
#include <QMessageBox>
#include <QPalette>
#include <QTimer>
QmitkPointListView::QmitkPointListView(QWidget *parent)
: QListView(parent),
m_PointListModel(new QmitkPointListModel()),
m_SelfCall(false),
m_showFading(false),
m_MultiWidget(nullptr)
{
QListView::setAlternatingRowColors(true);
QListView::setSelectionBehavior(QAbstractItemView::SelectItems);
QListView::setSelectionMode(QAbstractItemView::SingleSelection);
QListView::setModel(m_PointListModel);
QString tooltip = QString("Use the F2/F3 keys to move a point up/down, the Del key to remove a point\nand the mouse "
"wheel to change the timestep.\n\nTimeStep:\t%1")
.arg(0);
QListView::setToolTip(tooltip);
this->setContextMenuPolicy(Qt::CustomContextMenu);
this->setMinimumHeight(40);
this->setSizePolicy(QSizePolicy::Ignored, QSizePolicy::Ignored);
connect(m_PointListModel, SIGNAL(SignalUpdateSelection()), this, SLOT(OnPointSetSelectionChanged()));
connect(this, SIGNAL(doubleClicked(const QModelIndex &)), this, SLOT(OnPointDoubleClicked(const QModelIndex &)));
connect(QListView::selectionModel(),
SIGNAL(selectionChanged(const QItemSelection &, const QItemSelection &)),
this,
SLOT(OnListViewSelectionChanged(const QItemSelection &, const QItemSelection &)));
// T28213: Every single action in the context menu is either not implemented or working. Implement/fix or remove in future.
// connect(this, SIGNAL(customContextMenuRequested(const QPoint &)), this, SLOT(ctxMenu(const QPoint &)));
}
QmitkPointListView::~QmitkPointListView()
{
delete m_PointListModel;
}
void QmitkPointListView::SetPointSetNode(mitk::DataNode *pointSetNode)
{
m_PointListModel->SetPointSetNode(pointSetNode);
}
const mitk::PointSet *QmitkPointListView::GetPointSet() const
{
return m_PointListModel->GetPointSet();
}
void QmitkPointListView::SetMultiWidget(QmitkAbstractMultiWidget* multiWidget)
{
m_MultiWidget = multiWidget;
if (nullptr != m_MultiWidget)
{
for (const auto& renderWindow : m_MultiWidget->GetRenderWindows().values())
{
AddSliceNavigationController(renderWindow->GetSliceNavigationController());
}
}
}
QmitkAbstractMultiWidget* QmitkPointListView::GetMultiWidget() const
{
return m_MultiWidget;
}
void QmitkPointListView::OnPointDoubleClicked(const QModelIndex &index)
{
mitk::PointSet::PointType p;
mitk::PointSet::PointIdentifier id;
m_PointListModel->GetPointForModelIndex(index, p, id);
QmitkEditPointDialog _EditPointDialog(this);
_EditPointDialog.SetPoint(m_PointListModel->GetPointSet(), id, m_PointListModel->GetTimeStep());
_EditPointDialog.exec();
}
void QmitkPointListView::OnPointSetSelectionChanged()
{
const mitk::PointSet *pointSet = m_PointListModel->GetPointSet();
if (pointSet == nullptr)
return;
// update this view's selection status as a result to changes in the point set data structure
m_SelfCall = true;
int timeStep = m_PointListModel->GetTimeStep();
if (pointSet->GetNumberOfSelected(timeStep) > 1)
{
MITK_ERROR << "Point set has multiple selected points. This view is not designed for more than one selected point.";
}
int selectedIndex = pointSet->SearchSelectedPoint(timeStep);
if (selectedIndex == -1) // no selected point is found
{
m_SelfCall = false;
return;
}
QModelIndex index;
bool modelIndexOkay = m_PointListModel->GetModelIndexForPointID(selectedIndex, index);
if (modelIndexOkay == true)
QListView::selectionModel()->select(index, QItemSelectionModel::ClearAndSelect);
emit SignalPointSelectionChanged();
m_SelfCall = false;
}
void QmitkPointListView::OnListViewSelectionChanged(const QItemSelection &selected,
const QItemSelection & /*deselected*/)
{
if (m_SelfCall)
return;
mitk::PointSet *pointSet = const_cast<mitk::PointSet *>(m_PointListModel->GetPointSet());
if (pointSet == nullptr)
return;
// (take care that this widget doesn't react to self-induced changes by setting m_SelfCall)
m_SelfCall = true;
// update selection of all points in pointset: select the one(s) that are selected in the view, deselect all others
QModelIndexList selectedIndexes = selected.indexes();
// only call setSelectInfo on a point set with 'selected = true' if you deselcted the other entries
int indexToSelect = -1;
for (mitk::PointSet::PointsContainer::Iterator it =
pointSet->GetPointSet(m_PointListModel->GetTimeStep())->GetPoints()->Begin();
it != pointSet->GetPointSet(m_PointListModel->GetTimeStep())->GetPoints()->End();
++it)
{
QModelIndex index;
if (m_PointListModel->GetModelIndexForPointID(it->Index(), index))
{
if (selectedIndexes.indexOf(index) != -1) // index is found in the selected indices list
{
indexToSelect = it->Index();
}
else
{
pointSet->SetSelectInfo(it->Index(), false, m_PointListModel->GetTimeStep());
}
}
}
// force selection of only one index after deselecting the others
if (indexToSelect > -1) {
pointSet->SetSelectInfo(indexToSelect, true, m_PointListModel->GetTimeStep());
mitk::Point3D p = pointSet->GetPoint(indexToSelect, m_PointListModel->GetTimeStep());
for (auto snc : m_Sncs)
snc->SelectSliceByPoint(p);
}
m_SelfCall = false;
emit SignalPointSelectionChanged();
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
void QmitkPointListView::keyPressEvent(QKeyEvent *e)
{
if (m_PointListModel == nullptr)
return;
int key = e->key();
switch (key)
{
case Qt::Key_F2:
m_PointListModel->MoveSelectedPointUp();
break;
case Qt::Key_F3:
m_PointListModel->MoveSelectedPointDown();
break;
case Qt::Key_Delete:
m_PointListModel->RemoveSelectedPoint();
break;
default:
break;
}
}
void QmitkPointListView::wheelEvent(QWheelEvent *event)
{
if (!m_PointListModel || !m_PointListModel->GetPointSet() ||
(int)(m_PointListModel->GetPointSet()->GetTimeSteps()) == 1)
return;
- int whe = event->delta();
+ int whe = event->angleDelta().y();
mitk::PointSet::Pointer ps = dynamic_cast<mitk::PointSet *>(m_PointListModel->GetPointSet());
unsigned int numberOfTS = ps->GetTimeSteps();
if (numberOfTS == 1)
return;
int currentTS = this->m_PointListModel->GetTimeStep();
if (whe > 0)
{
if ((currentTS + 1 >= (int)numberOfTS))
return;
this->m_PointListModel->SetTimeStep(++currentTS);
}
else
{
if ((currentTS <= 0))
return;
this->m_PointListModel->SetTimeStep(--currentTS);
}
QString tooltip = QString("Use the F2/F3 keys to move a point up/down, the Del key to remove a point\nand the mouse "
"wheel to change the timestep.\n\nTimeStep:\t%1")
.arg(currentTS);
this->setToolTip(tooltip);
emit SignalTimeStepChanged(currentTS);
}
void QmitkPointListView::ctxMenu(const QPoint &pos)
{
QMenu *menu = new QMenu;
// add Fading check
QAction *showFading = new QAction(this);
showFading->setCheckable(false); // TODO: reset when fading is working
showFading->setEnabled(false); // TODO: reset when fading is working
showFading->setText("Fade TimeStep");
connect(showFading, SIGNAL(triggered(bool)), this, SLOT(SetFading(bool)));
menu->addAction(showFading);
// add Clear action
QAction *clearList = new QAction(this);
clearList->setText("Clear List");
connect(clearList, SIGNAL(triggered()), this, SLOT(ClearPointList()));
menu->addAction(clearList);
// add Clear TimeStep action
QAction *clearTS = new QAction(this);
clearTS->setText("Clear current time step");
connect(clearTS, SIGNAL(triggered()), this, SLOT(ClearPointListTS()));
menu->addAction(clearTS);
menu->exec(this->mapToGlobal(pos));
}
void QmitkPointListView::SetFading(bool onOff)
{
m_showFading = onOff;
}
void QmitkPointListView::ClearPointList()
{
if (!m_PointListModel->GetPointSet())
return;
mitk::PointSet::Pointer curPS = m_PointListModel->GetPointSet();
if (curPS->GetSize() == 0)
return;
switch (QMessageBox::question(this,
tr("Clear Points"),
tr("Remove all points from the displayed list?"),
QMessageBox::Yes | QMessageBox::No,
QMessageBox::No))
{
case QMessageBox::Yes:
{
mitk::PointSet::PointsIterator it;
mitk::PointSet::PointsContainer *curPsPoints;
while (!curPS->IsEmptyTimeStep(0))
{
curPsPoints = curPS->GetPointSet()->GetPoints();
it = curPsPoints->Begin();
curPS->SetSelectInfo(it->Index(), true);
m_PointListModel->RemoveSelectedPoint();
}
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
break;
}
case QMessageBox::No:
default:
break;
}
}
void QmitkPointListView::ClearPointListTS()
{
}
void QmitkPointListView::AddSliceNavigationController(mitk::SliceNavigationController *snc)
{
if (snc == nullptr)
return;
m_Sncs.insert(snc);
}
void QmitkPointListView::RemoveSliceNavigationController(mitk::SliceNavigationController *snc)
{
if (snc == nullptr)
return;
m_Sncs.erase(snc);
}
diff --git a/Modules/QtWidgetsExt/src/QmitkSliceWidget.cpp b/Modules/QtWidgetsExt/src/QmitkSliceWidget.cpp
index 69da61ffbb..c3ec916a01 100644
--- a/Modules/QtWidgetsExt/src/QmitkSliceWidget.cpp
+++ b/Modules/QtWidgetsExt/src/QmitkSliceWidget.cpp
@@ -1,266 +1,266 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include "QmitkSliceWidget.h"
#include "QmitkStepperAdapter.h"
#include "mitkCameraController.h"
#include "mitkImage.h"
#include "mitkNodePredicateDataType.h"
#include <QMenu>
#include <QMouseEvent>
#include <mitkCameraController.h>
#include <mitkProportionalTimeGeometry.h>
QmitkSliceWidget::QmitkSliceWidget(QWidget *parent, const char *name, Qt::WindowFlags f) : QWidget(parent, f)
{
this->setupUi(this);
if (name != nullptr)
this->setObjectName(name);
popUp = new QMenu(this);
popUp->addAction("Axial");
popUp->addAction("Coronal");
popUp->addAction("Sagittal");
QObject::connect(popUp, SIGNAL(triggered(QAction *)), this, SLOT(ChangeView(QAction *)));
setPopUpEnabled(false);
m_SlicedGeometry = nullptr;
m_View = mitk::AnatomicalPlane::Axial;
QHBoxLayout *hlayout = new QHBoxLayout(container);
hlayout->setContentsMargins({});
// create widget
QString composedName("QmitkSliceWidget::");
if (!this->objectName().isEmpty())
composedName += this->objectName();
else
composedName += "QmitkGLWidget";
m_RenderWindow = new QmitkRenderWindow(container, composedName);
m_Renderer = m_RenderWindow->GetRenderer();
hlayout->addWidget(m_RenderWindow);
new QmitkStepperAdapter(sliceNavigationWidget, m_RenderWindow->GetSliceNavigationController()->GetStepper());
SetLevelWindowEnabled(true);
}
mitk::VtkPropRenderer *QmitkSliceWidget::GetRenderer()
{
return m_Renderer;
}
QFrame *QmitkSliceWidget::GetSelectionFrame()
{
return SelectionFrame;
}
void QmitkSliceWidget::SetDataStorage(mitk::StandaloneDataStorage::Pointer storage)
{
m_DataStorage = storage;
m_Renderer->SetDataStorage(m_DataStorage);
}
mitk::StandaloneDataStorage *QmitkSliceWidget::GetDataStorage()
{
return m_DataStorage;
}
void QmitkSliceWidget::SetData(mitk::DataStorage::SetOfObjects::ConstIterator it)
{
SetData(it->Value(), m_View);
}
void QmitkSliceWidget::SetData(mitk::DataStorage::SetOfObjects::ConstIterator it,
mitk::AnatomicalPlane view)
{
SetData(it->Value(), view);
}
void QmitkSliceWidget::SetData(mitk::DataNode::Pointer node)
{
try
{
if (m_DataStorage.IsNotNull())
{
m_DataStorage->Add(node);
}
}
catch (...)
{
}
SetData(node, m_View);
}
void QmitkSliceWidget::SetData(mitk::DataNode::Pointer node, mitk::AnatomicalPlane view)
{
mitk::Image::Pointer image = dynamic_cast<mitk::Image *>(node->GetData());
if (image.IsNull())
{
MITK_WARN << "QmitkSliceWidget data is not an image!";
return;
}
m_SlicedGeometry = image->GetSlicedGeometry();
this->InitWidget(view);
}
void QmitkSliceWidget::InitWidget(mitk::AnatomicalPlane view)
{
m_View = view;
mitk::SliceNavigationController *controller = m_RenderWindow->GetSliceNavigationController();
if (view == mitk::AnatomicalPlane::Axial)
{
controller->SetViewDirection(mitk::AnatomicalPlane::Axial);
}
else if (view == mitk::AnatomicalPlane::Coronal)
{
controller->SetViewDirection(mitk::AnatomicalPlane::Coronal);
}
// init sagittal view for all other cases ('original' is covered here as well)
else
{
controller->SetViewDirection(mitk::AnatomicalPlane::Sagittal);
}
if (m_SlicedGeometry.IsNull())
{
return;
}
mitk::BaseGeometry::Pointer geometry = static_cast<mitk::BaseGeometry *>(m_SlicedGeometry->Clone().GetPointer());
const mitk::BoundingBox::Pointer boundingbox = m_DataStorage->ComputeVisibleBoundingBox(GetRenderer(), nullptr);
if (boundingbox->GetPoints()->Size() > 0)
{
// let's see if we have data with a limited live-span ...
mitk::TimeBounds timebounds = m_DataStorage->ComputeTimeBounds(GetRenderer(), nullptr);
mitk::ProportionalTimeGeometry::Pointer timeGeometry = mitk::ProportionalTimeGeometry::New();
timeGeometry->Initialize(geometry, 1);
{
timeGeometry->SetFirstTimePoint(timebounds[0]);
timeGeometry->SetStepDuration(1.0);
}
if (timeGeometry->GetBoundingBoxInWorld()->GetDiagonalLength2() >= mitk::eps)
{
controller->SetInputWorldTimeGeometry(timeGeometry);
controller->Update();
}
}
GetRenderer()->GetCameraController()->Fit();
mitk::RenderingManager::GetInstance()->RequestUpdate(GetRenderer()->GetRenderWindow());
}
void QmitkSliceWidget::UpdateGL()
{
GetRenderer()->GetCameraController()->Fit();
mitk::RenderingManager::GetInstance()->RequestUpdate(GetRenderer()->GetRenderWindow());
}
void QmitkSliceWidget::mousePressEvent(QMouseEvent *e)
{
if (e->button() == Qt::RightButton && popUpEnabled)
{
popUp->popup(QCursor::pos());
}
}
void QmitkSliceWidget::wheelEvent(QWheelEvent *e)
{
int val = sliceNavigationWidget->GetPos();
- if (e->orientation() * e->delta() > 0)
+ if (e->angleDelta().y() > 0)
{
sliceNavigationWidget->SetPos(val + 1);
}
else
{
if (val > 0)
sliceNavigationWidget->SetPos(val - 1);
}
}
void QmitkSliceWidget::ChangeView(QAction *val)
{
if (val->text() == "Axial")
{
InitWidget(mitk::AnatomicalPlane::Axial);
}
else if (val->text() == "Coronal")
{
InitWidget(mitk::AnatomicalPlane::Coronal);
}
else if (val->text() == "Sagittal")
{
InitWidget(mitk::AnatomicalPlane::Sagittal);
}
}
void QmitkSliceWidget::setPopUpEnabled(bool b)
{
popUpEnabled = b;
}
QmitkSliceNavigationWidget* QmitkSliceWidget::GetSliceNavigationWidget()
{
return sliceNavigationWidget;
}
void QmitkSliceWidget::SetLevelWindowEnabled(bool enable)
{
levelWindow->setEnabled(enable);
if (!enable)
{
levelWindow->setMinimumWidth(0);
levelWindow->setMaximumWidth(0);
}
else
{
levelWindow->setMinimumWidth(28);
levelWindow->setMaximumWidth(28);
}
}
bool QmitkSliceWidget::IsLevelWindowEnabled()
{
return levelWindow->isEnabled();
}
QmitkRenderWindow *QmitkSliceWidget::GetRenderWindow()
{
return m_RenderWindow;
}
mitk::SliceNavigationController *QmitkSliceWidget::GetSliceNavigationController() const
{
return m_RenderWindow->GetSliceNavigationController();
}
mitk::CameraRotationController *QmitkSliceWidget::GetCameraRotationController() const
{
return m_RenderWindow->GetCameraRotationController();
}
mitk::BaseController *QmitkSliceWidget::GetController() const
{
return m_RenderWindow->GetController();
}
diff --git a/Plugins/org.blueberry.ui.qt.help/src/internal/berryHelpWebView.cpp b/Plugins/org.blueberry.ui.qt.help/src/internal/berryHelpWebView.cpp
index 95f80daed9..55ebd3efc6 100644
--- a/Plugins/org.blueberry.ui.qt.help/src/internal/berryHelpWebView.cpp
+++ b/Plugins/org.blueberry.ui.qt.help/src/internal/berryHelpWebView.cpp
@@ -1,450 +1,450 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include "berryHelpWebView.h"
#include "berryHelpPluginActivator.h"
#include "berryHelpEditor.h"
#include "berryHelpEditorInput.h"
#include "berryQHelpEngineWrapper.h"
#include <berryIWorkbenchPage.h>
#include <QCoreApplication>
#include <QTimer>
#include <QStringBuilder>
#include <QTemporaryFile>
#include <QDesktopServices>
#include <QWheelEvent>
#include <QWebEngineSettings>
#include <QWebEngineUrlSchemeHandler>
#include <QWebEngineUrlRequestJob>
#include <QWebEngineProfile>
namespace berry {
struct ExtensionMap {
const char *extension;
const char *mimeType;
} extensionMap[] = {
{ ".bmp", "image/bmp" },
{ ".css", "text/css" },
{ ".gif", "image/gif" },
{ ".html", "text/html" },
{ ".htm", "text/html" },
{ ".ico", "image/x-icon" },
{ ".jpeg", "image/jpeg" },
{ ".jpg", "image/jpeg" },
{ ".js", "application/x-javascript" },
{ ".mng", "video/x-mng" },
{ ".pbm", "image/x-portable-bitmap" },
{ ".pgm", "image/x-portable-graymap" },
{ ".pdf", "application/pdf" },
{ ".png", "image/png" },
{ ".ppm", "image/x-portable-pixmap" },
{ ".rss", "application/rss+xml" },
{ ".svg", "image/svg+xml" },
{ ".svgz", "image/svg+xml" },
{ ".text", "text/plain" },
{ ".tif", "image/tiff" },
{ ".tiff", "image/tiff" },
{ ".txt", "text/plain" },
{ ".xbm", "image/x-xbitmap" },
{ ".xml", "text/xml" },
{ ".xpm", "image/x-xpm" },
{ ".xsl", "text/xsl" },
{ ".xhtml", "application/xhtml+xml" },
{ ".wml", "text/vnd.wap.wml" },
{ ".wmlc", "application/vnd.wap.wmlc" },
{ "about:blank", nullptr },
{ nullptr, nullptr }
};
class HelpDeviceReply final : public QIODevice
{
public:
HelpDeviceReply(const QUrl& request, const QByteArray& fileData);
~HelpDeviceReply() override;
qint64 bytesAvailable() const override;
void close() override;
private:
qint64 readData(char* data, qint64 maxlen) override;
qint64 writeData(const char* data, qint64 maxlen) override;
QByteArray m_Data;
const qint64 m_OrigLen;
};
HelpDeviceReply::HelpDeviceReply(const QUrl&, const QByteArray& fileData)
: m_Data(fileData),
m_OrigLen(fileData.length())
{
this->setOpenMode(QIODevice::ReadOnly);
QTimer::singleShot(0, this, &QIODevice::readyRead);
QTimer::singleShot(0, this, &QIODevice::readChannelFinished);
}
HelpDeviceReply::~HelpDeviceReply()
{
}
qint64 HelpDeviceReply::bytesAvailable() const
{
return m_Data.length() + QIODevice::bytesAvailable();
}
void HelpDeviceReply::close()
{
QIODevice::close();
this->deleteLater();
}
qint64 HelpDeviceReply::readData(char* data, qint64 maxlen)
{
qint64 len = qMin(qint64(m_Data.length()), maxlen);
if (len)
{
memcpy(data, m_Data.constData(), len);
m_Data.remove(0, len);
}
return len;
}
qint64 HelpDeviceReply::writeData(const char*, qint64)
{
return 0;
}
class HelpUrlSchemeHandler final : public QWebEngineUrlSchemeHandler
{
public:
explicit HelpUrlSchemeHandler(QObject* parent = nullptr);
~HelpUrlSchemeHandler() override;
void requestStarted(QWebEngineUrlRequestJob* job) override;
};
HelpUrlSchemeHandler::HelpUrlSchemeHandler(QObject* parent)
: QWebEngineUrlSchemeHandler(parent)
{
}
HelpUrlSchemeHandler::~HelpUrlSchemeHandler()
{
}
enum class ResolveUrlResult
{
Error,
Redirect,
Data
};
ResolveUrlResult ResolveUrl(const QUrl& url, QUrl& redirectedUrl, QByteArray& data)
{
auto& helpEngine = HelpPluginActivator::getInstance()->getQHelpEngine();
const auto targetUrl = helpEngine.findFile(url);
if (!targetUrl.isValid())
return ResolveUrlResult::Error;
if (targetUrl != url)
{
redirectedUrl = targetUrl;
return ResolveUrlResult::Redirect;
}
data = helpEngine.fileData(targetUrl);
return ResolveUrlResult::Data;
}
void HelpUrlSchemeHandler::requestStarted(QWebEngineUrlRequestJob* job)
{
QUrl url = job->requestUrl();
QUrl redirectedUrl;
QByteArray data;
switch (ResolveUrl(url, redirectedUrl, data))
{
case ResolveUrlResult::Data:
job->reply(
HelpWebView::mimeFromUrl(url).toLatin1(),
new HelpDeviceReply(url, data));
break;
case ResolveUrlResult::Redirect:
job->redirect(redirectedUrl);
break;
case ResolveUrlResult::Error:
job->reply(
QByteArrayLiteral("text/html"),
new HelpDeviceReply(url, HelpWebView::m_PageNotFoundMessage.arg(url.toString()).toUtf8()));
break;
}
}
const QString HelpWebView::m_PageNotFoundMessage =
QCoreApplication::translate("org.blueberry.ui.qt.help", "<title>Context Help</title><div "
"align=\"center\"><br><br><h1>No help page found for identifier</h1><br><h3>'%1'"
"</h3></div>");
const QString HelpWebView::m_MissingContextMessage =
QCoreApplication::translate("org.blueberry.ui.qt.help", "<title>Context Help</title><div "
"align=\"center\"><br><br><h1>Unknown context..</h1><h1> </h1><h1>Please click inside a view and hit F1 again!</h1></div>");
class HelpPage final : public QWebEnginePage
{
public:
explicit HelpPage(QObject* parent = nullptr);
~HelpPage() override;
private:
bool acceptNavigationRequest(const QUrl& url, NavigationType type, bool isMainFrame) override;
};
HelpPage::HelpPage(QObject* parent)
: QWebEnginePage(parent)
{
}
HelpPage::~HelpPage()
{
}
bool HelpPage::acceptNavigationRequest(const QUrl& url, NavigationType, bool)
{
if (url.scheme().contains("http"))
{
QDesktopServices::openUrl(url);
return false;
}
return true;
}
HelpWebView::HelpWebView(IEditorSite::Pointer, QWidget *parent, qreal zoom)
: QWebEngineView(parent),
m_LoadFinished(false),
m_HelpEngine(HelpPluginActivator::getInstance()->getQHelpEngine()),
m_HelpSchemeHandler(new HelpUrlSchemeHandler(this))
{
QWebEngineProfile::defaultProfile()->installUrlSchemeHandler("qthelp", m_HelpSchemeHandler);
auto helpPage = new HelpPage(this);
this->setPage(helpPage);
this->setAcceptDrops(false);
auto action = pageAction(QWebEnginePage::OpenLinkInNewWindow);
action->setText("Open Link in New Tab");
if (parent == nullptr)
action->setVisible(false);
this->pageAction(QWebEnginePage::DownloadLinkToDisk)->setVisible(false);
this->pageAction(QWebEnginePage::DownloadImageToDisk)->setVisible(false);
connect(pageAction(QWebEnginePage::Copy), SIGNAL(changed()), this, SLOT(actionChanged()));
connect(pageAction(QWebEnginePage::Back), SIGNAL(changed()), this, SLOT(actionChanged()));
connect(pageAction(QWebEnginePage::Forward), SIGNAL(changed()), this, SLOT(actionChanged()));
connect(page(), SIGNAL(linkHovered(QString)), this, SIGNAL(highlighted(QString)));
connect(this, SIGNAL(urlChanged(QUrl)), this, SIGNAL(sourceChanged(QUrl)));
connect(this, SIGNAL(loadStarted()), this, SLOT(setLoadStarted()));
connect(this, SIGNAL(loadFinished(bool)), this, SLOT(setLoadFinished(bool)));
this->setFont(this->viewerFont());
this->setZoomFactor(zoom == 0.0 ? 1.0 : zoom);
}
HelpWebView::~HelpWebView()
{
}
QFont HelpWebView::viewerFont() const
{
QWebEngineSettings *webSettings = QWebEngineSettings::globalSettings();
return QFont(webSettings->fontFamily(QWebEngineSettings::StandardFont),
webSettings->fontSize(QWebEngineSettings::DefaultFontSize));
}
void HelpWebView::setViewerFont(const QFont &font)
{
QWebEngineSettings *webSettings = settings();
webSettings->setFontFamily(QWebEngineSettings::StandardFont, font.family());
webSettings->setFontSize(QWebEngineSettings::DefaultFontSize, font.pointSize());
}
void HelpWebView::scaleUp()
{
setZoomFactor(zoomFactor() + 0.1);
}
void HelpWebView::scaleDown()
{
setZoomFactor(qMax(0.0, zoomFactor() - 0.1));
}
void HelpWebView::resetScale()
{
setZoomFactor(1.0);
}
bool HelpWebView::handleForwardBackwardMouseButtons(QMouseEvent *e)
{
if (e->button() == Qt::XButton1)
{
triggerPageAction(QWebEnginePage::Back);
return true;
}
if (e->button() == Qt::XButton2)
{
triggerPageAction(QWebEnginePage::Forward);
return true;
}
return false;
}
void HelpWebView::setSource(const QUrl &url)
{
if (url.toString().trimmed().isEmpty()) {
setHtml(m_MissingContextMessage);
}
else if (m_HelpEngine.findFile(url).isValid())
{
load(url);
}
else
{
setHtml(m_PageNotFoundMessage.arg(url.toString()));
}
}
void HelpWebView::wheelEvent(QWheelEvent *e)
{
if (e->modifiers()& Qt::ControlModifier)
{
e->accept();
- e->delta() > 0 ? scaleUp() : scaleDown();
+ e->angleDelta().y() > 0 ? scaleUp() : scaleDown();
}
else
{
QWebEngineView::wheelEvent(e);
}
}
void HelpWebView::actionChanged()
{
QAction *a = qobject_cast<QAction *>(sender());
if (a == pageAction(QWebEnginePage::Copy))
emit copyAvailable(a->isEnabled());
else if (a == pageAction(QWebEnginePage::Back))
emit backwardAvailable(a->isEnabled());
else if (a == pageAction(QWebEnginePage::Forward))
emit forwardAvailable(a->isEnabled());
}
void HelpWebView::setLoadStarted()
{
m_LoadFinished = false;
}
void HelpWebView::setLoadFinished(bool ok)
{
m_LoadFinished = ok;
emit sourceChanged(url());
}
QString HelpWebView::mimeFromUrl(const QUrl &url)
{
const QString &path = url.path();
const int index = path.lastIndexOf(QLatin1Char('.'));
const QByteArray &ext = path.mid(index).toUtf8().toLower();
const ExtensionMap *e = extensionMap;
while (e->extension)
{
if (ext == e->extension)
return QLatin1String(e->mimeType);
++e;
}
return QLatin1String("");
}
bool HelpWebView::canOpenPage(const QString &url)
{
return !mimeFromUrl(url).isEmpty();
}
bool HelpWebView::isLocalUrl(const QUrl &url)
{
const QString &scheme = url.scheme();
return scheme.isEmpty()
|| scheme == QLatin1String("file")
|| scheme == QLatin1String("qrc")
|| scheme == QLatin1String("data")
|| scheme == QLatin1String("qthelp")
|| scheme == QLatin1String("about");
}
bool HelpWebView::launchWithExternalApp(const QUrl &url)
{
if (isLocalUrl(url))
{
const QHelpEngine& helpEngine = HelpPluginActivator::getInstance()->getQHelpEngine();
const QUrl &resolvedUrl = helpEngine.findFile(url);
if (!resolvedUrl.isValid())
return false;
const QString& path = resolvedUrl.path();
if (!canOpenPage(path))
{
QTemporaryFile tmpTmpFile;
if (!tmpTmpFile.open())
return false;
const QString &extension = QFileInfo(path).completeSuffix();
QFile actualTmpFile(tmpTmpFile.fileName() % QLatin1String(".")
% extension);
if (!actualTmpFile.open(QIODevice::ReadWrite | QIODevice::Truncate))
return false;
actualTmpFile.write(helpEngine.fileData(resolvedUrl));
actualTmpFile.close();
return QDesktopServices::openUrl(QUrl(actualTmpFile.fileName()));
}
}
else if (url.scheme() == QLatin1String("http"))
{
return QDesktopServices::openUrl(url);
}
return false;
}
void HelpWebView::home()
{
setSource(m_HelpEngine.homePage());
}
}