diff --git a/Modules/QtWidgets/include/QmitkRenderWindow.h b/Modules/QtWidgets/include/QmitkRenderWindow.h
index 8194a8ddc0..2aa0b9e4b7 100644
--- a/Modules/QtWidgets/include/QmitkRenderWindow.h
+++ b/Modules/QtWidgets/include/QmitkRenderWindow.h
@@ -1,165 +1,165 @@
/*============================================================================
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.
============================================================================*/
#ifndef QmitkRenderWindow_h
#define QmitkRenderWindow_h
#include "mitkRenderWindowBase.h"
#include "QmitkRenderWindowMenu.h"
#include <MitkQtWidgetsExports.h>
#include <vtkGenericOpenGLRenderWindow.h>
#include <QVTKOpenGLNativeWidget.h>
#include "mitkBaseRenderer.h"
#include "mitkInteractionEventConst.h"
#include <QmitkButtonOverlayWidget.h>
class QDragEnterEvent;
class QDropEvent;
class QInputEvent;
class QMouseEvent;
/**
* \ingroup QmitkModule
* \brief MITK implementation of the QVTKWidget
*/
class MITKQTWIDGETS_EXPORT QmitkRenderWindow : public QVTKOpenGLNativeWidget, public mitk::RenderWindowBase
{
Q_OBJECT
public:
QmitkRenderWindow(
QWidget *parent = nullptr,
const QString &name = "unnamed renderwindow",
mitk::VtkPropRenderer *renderer = nullptr);
~QmitkRenderWindow() override;
/**
* \brief Whether Qt events should be passed to parent (default: true)
*
* With introduction of the QVTKWidget the behaviour regarding Qt events changed.
* QVTKWidget "accepts" Qt events like mouse clicks (i.e. set an "accepted" flag).
* When this flag is set, Qt fininshed handling of this event -- otherwise it is
* reached through to the widget's parent.
*
* This reaching through to the parent was implicitly required by QmitkMaterialWidget / QmitkMaterialShowCase.
*
* The default behaviour of QmitkRenderWindow is now to clear the "accepted" flag
* of Qt events after they were handled by QVTKWidget. This way parents can also
* handle events.
*
* If you don't want this behaviour, call SetResendQtEvents(true) on your render window.
*/
virtual void SetResendQtEvents(bool resend);
// Set Layout Index to define the Layout Type
void SetLayoutIndex(QmitkRenderWindowMenu::LayoutIndex layoutIndex);
// Get Layout Index to define the Layout Type
QmitkRenderWindowMenu::LayoutIndex GetLayoutIndex();
// MenuWidget need to update the Layout Design List when Layout had changed
void UpdateLayoutDesignList(QmitkRenderWindowMenu::LayoutDesign layoutDesign);
void UpdateCrosshairVisibility(bool);
void UpdateCrosshairRotationMode(int);
// Activate or Deactivate MenuWidget.
void ActivateMenuWidget(bool state);
bool GetActivateMenuWidgetFlag() { return m_MenuWidgetActivated; }
void ShowOverlayMessage(bool show);
// Get it from the QVTKWidget parent
vtkRenderWindow *GetVtkRenderWindow() override { return this->renderWindow(); }
vtkRenderWindowInteractor *GetVtkRenderWindowInteractor() override { return nullptr; }
protected:
// catch-all event handler
bool event(QEvent *e) override;
// overloaded move handler
void moveEvent(QMoveEvent *event) override;
// overloaded show handler
void showEvent(QShowEvent *event) override;
// overloaded enter handler
- void enterEvent(QEvent *) override;
+ void enterEvent(QEnterEvent *) override;
// overloaded leave handler
void leaveEvent(QEvent *) override;
// Overloaded resize handler, see decs in QVTKOpenGLWidget.
// Basically, we have to ensure the VTK rendering is updated for each change in window size.
void resizeGL(int w, int h) override;
/// \brief Simply says we accept the event type.
void dragEnterEvent(QDragEnterEvent *event) override;
/// \brief If the dropped type is application/x-mitk-datanodes we process the request by converting to mitk::DataNode
/// pointers and emitting the NodesDropped signal.
void dropEvent(QDropEvent *event) override;
Q_SIGNALS:
void LayoutDesignChanged(QmitkRenderWindowMenu::LayoutDesign);
void ResetView();
void ResetGeometry();
void CrosshairRotationModeChanged(int);
void CrosshairVisibilityChanged(bool);
void moved();
/// \brief Emits a signal to say that this window has had the following nodes dropped on it.
void NodesDropped(QmitkRenderWindow *thisWindow, std::vector<mitk::DataNode *> nodes);
private Q_SLOTS:
void DeferredHideMenu();
private:
// Helper Functions to Convert Qt-Events to Mitk-Events
mitk::Point2D GetMousePosition(QMouseEvent *me) const;
mitk::Point2D GetMousePosition(QWheelEvent *we) const;
mitk::InteractionEvent::MouseButtons GetEventButton(QMouseEvent *me) const;
mitk::InteractionEvent::MouseButtons GetButtonState(QMouseEvent *me) const;
mitk::InteractionEvent::ModifierKeys GetModifiers(QInputEvent *me) const;
mitk::InteractionEvent::MouseButtons GetButtonState(QWheelEvent *we) const;
std::string GetKeyLetter(QKeyEvent *ke) const;
int GetDelta(QWheelEvent *we) const;
void UpdateStatusBar(mitk::Point2D pointerPositionOnScreen);
bool m_ResendQtEvents;
QmitkRenderWindowMenu *m_MenuWidget;
bool m_MenuWidgetActivated;
QmitkRenderWindowMenu::LayoutIndex m_LayoutIndex;
vtkSmartPointer<vtkGenericOpenGLRenderWindow> m_InternalRenderWindow;
QmitkButtonOverlayWidget* m_GeometryViolationWarningOverlay;
};
#endif
diff --git a/Modules/QtWidgets/include/QmitkSliderLevelWindowWidget.h b/Modules/QtWidgets/include/QmitkSliderLevelWindowWidget.h
index b73f19c010..cc726fe505 100644
--- a/Modules/QtWidgets/include/QmitkSliderLevelWindowWidget.h
+++ b/Modules/QtWidgets/include/QmitkSliderLevelWindowWidget.h
@@ -1,188 +1,188 @@
/*============================================================================
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.
============================================================================*/
#ifndef QmitkSliderLevelWindowWidget_h
#define QmitkSliderLevelWindowWidget_h
#include <MitkQtWidgetsExports.h>
#include <QWidget>
#include <mitkLevelWindowManager.h>
class QmitkLevelWindowWidgetContextMenu;
/**
* \ingroup QmitkModule
*
* \brief Provides a widget with a slider to change the level and
* window value of the current image.
*
* This documentation actually refers to the QmitkLevelWindowWidget
* and is only put in this class due to technical issues (should be
* moved later).
*
* The QmitkLevelWindowWidget is a kind of container for a
* QmitkSliderLevelWindowWidget (this is the cyan bar above the text
* input fields) and a QmitkLineEditLevelWindowWidget (with two text
* input fields). It holds a reference to a mitk::LevelWindowManager
* variable, which keeps the LevelWindowProperty of the currently
* selected image. Level/Window is manipulated by the text inputs and
* the Slider to adjust brightness/contrast of a single image. All
* changes on the slider or in the text input fields affect the current
* image by giving new values to LevelWindowManager. LevelWindowManager
* then sends a signal to tell other listeners about changes.
*
* Which image is changed is determined by mitkLevelWindowManager. If
* m_AutoTopMost is true, always the topmost image in data tree (layer
* property) is affected by changes. The image which is affected by
* changes can also be changed by QmitkLevelWindowWidgetContextMenu,
* the context menu for QmitkSliderLevelWindowWidget and
* QmitkLineEditLevelWindowWidget. There you have the possibility to
* set a certain image or always the topmost image in the data tree
* (layer property) to be affected by changes.
*
* The internal mitk::LevelWindow variable contains a range that is
* valid for a given image. It should not be possible to move the
* level/window parameters outside this range. The range can be changed
* and reset to its default values by QmitkLevelWindowWidgetContextMenu,
* the context menu for QmitkSliderLevelWindowWidget and
* QmitkLineEditLevelWindowWidget.
*
* Now for the behaviour of the text inputs: The upper one contains the
* value of the level (brightness), the lower one shows the window (contrast).
*
* The behaviour of the cyan bar is more obvious: the scale in the
* background shows the valid range. The cyan bar in front displays the
* currently selected level/window setting. You can change the level by
* dragging the bar with the left mouse button or clicking somewhere inside
* the scalerange with the left mouse button. The window is changed by
* moving the mouse on the upper or lower bound of the bar until the cursor
* becomes an vertical double-arrowed symbol. Then you can change the
* windowsize by clicking the left mouse button and move the mouse upwards
* or downwards. The bar becomes greater upwards as well as downwards. If
* you want to change the size of the window in only one direction you
* have to press the CTRL-key while doing the same as mentioned above.
* This information is also presented by a tooltip text when moving the
* mouse on the upper or lower bound of the bar.
*/
class MITKQTWIDGETS_EXPORT QmitkSliderLevelWindowWidget : public QWidget
{
Q_OBJECT
public:
/// constructor
QmitkSliderLevelWindowWidget(QWidget *parent = nullptr, Qt::WindowFlags f = {});
/// destructor
~QmitkSliderLevelWindowWidget() override;
/// sets the manager who is responsible to collect and deliver changes on Level/Window
void SetLevelWindowManager(mitk::LevelWindowManager *levelWindowManager);
/// sets the DataStorage which holds all image-nodes
void SetDataStorage(mitk::DataStorage *ds);
/// returns the manager who is responsible to collect and deliver changes on Level/Window
mitk::LevelWindowManager *GetManager();
mitk::LevelWindow m_LevelWindow;
/// manager who is responsible to collect and deliver changes on Level/Window
mitk::LevelWindowManager::Pointer m_Manager;
private:
/// creates the context menu for this widget from class QmitkLevelWindowWidgetContextMenu
void contextMenuEvent(QContextMenuEvent *) override;
/// change notifications from the mitkLevelWindowManager
void OnPropertyModified(const itk::EventObject &e);
protected:
/// recalculate the size and position of the slider bar
virtual void Update();
/*!
* helper for drawing the component
*/
QRect m_Rect;
/*!
* helper for drawing the component
*/
QPoint m_StartPos;
bool m_Resize;
bool m_Bottom;
bool m_MouseDown;
bool m_Leftbutton;
bool m_CtrlPressed;
int m_MoveHeight;
bool m_ScaleVisible;
QRect m_LowerBound;
QRect m_UpperBound;
unsigned long m_ObserverTag;
bool m_IsObserverTagSet;
QFont m_Font;
/*!
* data structure which creates the context menu for QmitkLineEditLevelWindowWidget
*/
QmitkLevelWindowWidgetContextMenu *m_Contextmenu;
/*!
* repaint the slider and the scale
*/
void paintEvent(QPaintEvent *e) override;
/*!
* method implements the component behavior
*
* checks if cursor is on upper or lower bound of slider bar and changes cursor symbol
*
* checks if left mouse button is pressed and if CTRL is pressed and changes sliderbar in move-direction accordingly
*/
void mouseMoveEvent(QMouseEvent *mouseEvent) override;
- void enterEvent(QEvent *event) override;
+ void enterEvent(QEnterEvent *event) override;
/*!
* registers events when a mousebutton is pressed
*
* if leftbutton is pressed m_Leftbutton is set to true
*
* also checks if CTRL is pressed and sets the bool variable m_CtrlPressed
*/
void mousePressEvent(QMouseEvent *mouseEvent) override;
/*!
* sets the variable m_MouseDown to false
*/
void mouseReleaseEvent(QMouseEvent *mouseEvent) override;
/*!
* causes an update of the sliderbar when resizing the window
*/
void resizeEvent(QResizeEvent *event) override;
protected Q_SLOTS:
/** @brief Hide the scale if "Hide Scale" is selected in the context menu
*/
void HideScale();
/** @brief Shows the scale if "Show Scale" is selected in the context menu
*/
void ShowScale();
};
#endif
diff --git a/Modules/QtWidgets/src/QmitkRenderWindow.cpp b/Modules/QtWidgets/src/QmitkRenderWindow.cpp
index a478536dc4..9042d7fd31 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(QEvent *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;
// 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;
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::MidButton:
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::MidButton)
{
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::MidButton)
{
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();
}
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/QtWidgets/src/QmitkSliderLevelWindowWidget.cpp b/Modules/QtWidgets/src/QmitkSliderLevelWindowWidget.cpp
index 61eaf48f09..f837423397 100644
--- a/Modules/QtWidgets/src/QmitkSliderLevelWindowWidget.cpp
+++ b/Modules/QtWidgets/src/QmitkSliderLevelWindowWidget.cpp
@@ -1,550 +1,550 @@
/*============================================================================
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 <QmitkSliderLevelWindowWidget.h>
// mitk core
#include <mitkRenderingManager.h>
// mitk qt widgets
#include <QmitkLevelWindowWidgetContextMenu.h>
// qt
#include <QCursor>
#include <QMouseEvent>
#include <QPainter>
#include <QToolTip>
// itk
#include <itkCommand.h>
// c++
#include <cmath>
QmitkSliderLevelWindowWidget::QmitkSliderLevelWindowWidget(QWidget *parent, Qt::WindowFlags f)
: QWidget(parent, f)
{
m_Manager = mitk::LevelWindowManager::New();
itk::ReceptorMemberCommand<QmitkSliderLevelWindowWidget>::Pointer command =
itk::ReceptorMemberCommand<QmitkSliderLevelWindowWidget>::New();
command->SetCallbackFunction(this, &QmitkSliderLevelWindowWidget::OnPropertyModified);
m_ObserverTag = m_Manager->AddObserver(itk::ModifiedEvent(), command);
m_IsObserverTagSet = true;
setMouseTracking(true);
m_Resize = false;
m_Bottom = false;
m_CtrlPressed = false;
m_MouseDown = false;
m_Font.setPointSize(6);
m_MoveHeight = height() - 25;
m_ScaleVisible = true;
m_Contextmenu = new QmitkLevelWindowWidgetContextMenu(this);
this->hide();
Update();
}
QmitkSliderLevelWindowWidget::~QmitkSliderLevelWindowWidget()
{
if (m_IsObserverTagSet)
{
m_Manager->RemoveObserver(m_ObserverTag);
m_IsObserverTagSet = false;
}
}
void QmitkSliderLevelWindowWidget::SetLevelWindowManager(mitk::LevelWindowManager *levelWindowManager)
{
if (m_IsObserverTagSet)
{
m_Manager->RemoveObserver(m_ObserverTag);
m_IsObserverTagSet = false;
}
m_Manager = levelWindowManager;
if (m_Manager.IsNotNull())
{
itk::ReceptorMemberCommand<QmitkSliderLevelWindowWidget>::Pointer command =
itk::ReceptorMemberCommand<QmitkSliderLevelWindowWidget>::New();
command->SetCallbackFunction(this, &QmitkSliderLevelWindowWidget::OnPropertyModified);
m_ObserverTag = m_Manager->AddObserver(itk::ModifiedEvent(), command);
m_IsObserverTagSet = true;
}
}
void QmitkSliderLevelWindowWidget::OnPropertyModified(const itk::EventObject &)
{
try
{
m_LevelWindow = m_Manager->GetLevelWindow();
this->show();
Update();
}
catch (...)
{
try
{
this->hide();
}
catch (...)
{
}
}
}
void QmitkSliderLevelWindowWidget::paintEvent(QPaintEvent *itkNotUsed(e))
{
QPixmap pm(width(), height());
pm.fill(this->palette().color(this->backgroundRole()));
QPainter painter(&pm);
painter.setFont(m_Font);
painter.setPen(this->palette().color(this->foregroundRole()));
QColor c(51, 153, 204);
QColor cl = c.lighter();
QColor cd = c.darker();
painter.setBrush(c);
painter.drawRect(m_Rect);
mitk::ScalarType mr = m_LevelWindow.GetRange();
float smallestLevelableValue = 1e-9;
//This check is needed as safe guard. LevelWindow is refactored to only deduce finite ranges
//from images, but old scene serialization may contain infinite ranges that overwrite the new
//business logic. This roots in two many "jobs" LevelWindow" is used for; see also T24962.
//Until LevelWindow and this widget is refactored the check was the minimal invasive fix.
if (!std::isfinite(mr))
{
mr = m_LevelWindow.GetWindow();
}
// avoiding a division by 0 while still enabling small level windows
if (mr < smallestLevelableValue)
mr = smallestLevelableValue;
mitk::ScalarType fact = m_MoveHeight / mr;
// begin draw scale
if (m_ScaleVisible)
{
mitk::ScalarType minRange = m_LevelWindow.GetRangeMin();
mitk::ScalarType maxRange = m_LevelWindow.GetRangeMax();
//This check is needed as safe guard. LevelWindow is refactored to only deduce finite ranges
//from images, but old scene serialization may contain infinite ranges that overwrite the new
//business logic. This roots in two many "jobs" LevelWindow" is used for; see also T24962.
//Until LevelWindow and this widget is refactored the check was the minimal invasive fix.
if (!std::isfinite(minRange))
{
minRange = m_LevelWindow.GetLowerWindowBound();
}
//This check is needed as safe guard. LevelWindow is refactored to only deduce finite ranges
//from images, but old scene serialization may contain infinite ranges that overwrite the new
//business logic. This roots in two many "jobs" LevelWindow" is used for; see also T24962.
//Until LevelWindow and this widget is refactored the check was the minimal invasive fix.
if (!std::isfinite(maxRange))
{
maxRange = m_LevelWindow.GetUpperWindowBound();
}
int yValue = m_MoveHeight + static_cast<int>(minRange * fact);
QString s = " 0";
if (minRange < 0 && maxRange > 0)
{
painter.drawLine(5, yValue, 15, yValue);
painter.drawText(21, yValue + 3, s);
}
int count = 1;
int k = 5;
bool enoughSpace = false;
bool enoughSpace2 = false;
double dStepSize = pow(10, floor(log10(mr / 100)) + 1);
for (int i = m_MoveHeight + static_cast<int>(minRange * fact); i < m_MoveHeight;) // negative
{
if (-count * dStepSize < minRange)
{
break;
}
yValue = m_MoveHeight + static_cast<int>((minRange + count * dStepSize) * fact);
s = QString::number(-count * dStepSize);
if (count % k && ((dStepSize * fact) > 2.5))
{
painter.drawLine(8, yValue, 12, yValue);
enoughSpace = true;
}
else if (!(count % k))
{
if ((k * dStepSize * fact) > 7)
{
painter.drawLine(5, yValue, 15, yValue);
painter.drawText(21, yValue + 3, s);
enoughSpace2 = true;
}
else
{
k += 5;
}
}
if (enoughSpace)
{
i = yValue;
count++;
}
else if (enoughSpace2)
{
i = yValue;
count += k;
}
else
{
i = yValue;
count = k;
}
}
count = 1;
k = 5;
enoughSpace = false;
enoughSpace2 = false;
for (int i = m_MoveHeight + static_cast<int>(minRange * fact); i >= 0;)
{
if (count * dStepSize > maxRange)
{
break;
}
yValue = m_MoveHeight + static_cast<int>((minRange - count * dStepSize) * fact);
s = QString::number(count * dStepSize);
if (count % k && ((dStepSize * fact) > 2.5))
{
if (!(minRange > 0 && (count * dStepSize) < minRange))
painter.drawLine(8, yValue, 12, yValue);
enoughSpace = true;
}
else if (!(count % k))
{
if ((k * dStepSize * fact) > 7)
{
if (!(minRange > 0 && (count * dStepSize) < minRange))
{
painter.drawLine(5, yValue, 15, yValue);
painter.drawText(21, yValue + 3, s);
}
enoughSpace2 = true;
}
else
{
k += 5;
}
}
if (enoughSpace)
{
i = yValue;
count++;
}
else if (enoughSpace2)
{
i = yValue;
count += k;
}
else
{
i = yValue;
count = k;
}
}
}
// end draw scale
painter.setPen(cl);
painter.drawLine(m_Rect.topLeft(), m_Rect.topRight());
painter.drawLine(m_Rect.topLeft(), m_Rect.bottomLeft());
painter.setPen(cd);
painter.drawLine(m_Rect.topRight(), m_Rect.bottomRight());
painter.drawLine(m_Rect.bottomRight(), m_Rect.bottomLeft());
painter.end();
QPainter p(this);
p.drawPixmap(0, 0, pm);
}
void QmitkSliderLevelWindowWidget::mouseMoveEvent(QMouseEvent *mouseEvent)
{
if (!mouseEvent)
return;
if (m_LevelWindow.IsFixed())
return;
if (!m_MouseDown)
{
if (mouseEvent->pos().y() >= 0 && mouseEvent->pos().y() <= (m_Rect.topLeft().y() + 3))
{
setCursor(Qt::SizeVerCursor);
m_UpperBound.setRect(m_Rect.topLeft().x(), m_Rect.topLeft().y() - 3, 17, 7);
this->setToolTip("Ctrl + left click to change only upper bound");
m_Resize = true;
}
else if (mouseEvent->pos().y() >= (m_Rect.bottomLeft().y() - 3))
{
setCursor(Qt::SizeVerCursor);
m_LowerBound.setRect(m_Rect.bottomLeft().x(), m_Rect.bottomLeft().y() - 3, 17, 7);
this->setToolTip("Ctrl + left click to change only lower bound");
m_Resize = true;
m_Bottom = true;
}
else
{
setCursor(Qt::ArrowCursor);
this->setToolTip("Left click and mouse move to adjust the slider");
m_Resize = false;
m_Bottom = false;
}
}
else
{
mitk::ScalarType fact = m_MoveHeight / m_LevelWindow.GetRange();
if (m_Leftbutton)
{
if (m_Resize && !m_CtrlPressed)
{
mitk::ScalarType diff = (mouseEvent->pos().y()) / fact;
diff -= (m_StartPos.y()) / fact;
m_StartPos = mouseEvent->pos();
if (diff == 0)
return;
mitk::ScalarType value;
if (m_Bottom)
value = m_LevelWindow.GetWindow() + ((2 * diff));
else
value = m_LevelWindow.GetWindow() - ((2 * diff));
if (value < 0)
value = 0;
m_LevelWindow.SetLevelWindow(m_LevelWindow.GetLevel(), value);
}
else if (m_Resize && m_CtrlPressed)
{
if (!m_Bottom)
{
mitk::ScalarType diff = (mouseEvent->pos().y()) / fact;
diff -= (m_StartPos.y()) / fact;
m_StartPos = mouseEvent->pos();
if (diff == 0)
return;
mitk::ScalarType value;
value = m_LevelWindow.GetWindow() - ((diff));
if (value < 0)
value = 0;
mitk::ScalarType oldWindow;
mitk::ScalarType oldLevel;
mitk::ScalarType newLevel;
oldWindow = m_LevelWindow.GetWindow();
oldLevel = m_LevelWindow.GetLevel();
newLevel = oldLevel + (value - oldWindow) / 2;
if (!((newLevel + value / 2) > m_LevelWindow.GetRangeMax()))
m_LevelWindow.SetLevelWindow(newLevel, value);
}
else
{
mitk::ScalarType diff = (mouseEvent->pos().y()) / fact;
diff -= (m_StartPos.y()) / fact;
m_StartPos = mouseEvent->pos();
if (diff == 0)
return;
mitk::ScalarType value;
value = m_LevelWindow.GetWindow() + ((diff));
if (value < 0)
value = 0;
mitk::ScalarType oldWindow;
mitk::ScalarType oldLevel;
mitk::ScalarType newLevel;
oldWindow = m_LevelWindow.GetWindow();
oldLevel = m_LevelWindow.GetLevel();
newLevel = oldLevel - (value - oldWindow) / 2;
if (!((newLevel - value / 2) < m_LevelWindow.GetRangeMin()))
m_LevelWindow.SetLevelWindow(newLevel, value);
}
}
else
{
const mitk::ScalarType minv = m_LevelWindow.GetRangeMin();
const mitk::ScalarType level = (m_MoveHeight - mouseEvent->pos().y()) / fact + minv;
mitk::ScalarType diff = (mouseEvent->pos().x()) / fact;
diff -= (m_StartPos.x()) / fact;
m_StartPos = mouseEvent->pos();
mitk::ScalarType window;
if (m_Bottom)
window = m_LevelWindow.GetWindow() + ((2 * diff));
else
window = m_LevelWindow.GetWindow() - ((2 * diff));
if (window < 0)
window = 0;
m_LevelWindow.SetLevelWindow(level, window);
}
m_Manager->SetLevelWindow(m_LevelWindow);
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
}
}
-void QmitkSliderLevelWindowWidget::enterEvent(QEvent * /*event*/)
+void QmitkSliderLevelWindowWidget::enterEvent(QEnterEvent * /*event*/)
{
QPoint p = QCursor::pos();
p = this->mapFromGlobal(p);
QMouseEvent ev(QEvent::MouseMove, p, Qt::NoButton, Qt::NoButton, Qt::NoModifier);
this->mouseMoveEvent(&ev);
}
void QmitkSliderLevelWindowWidget::mousePressEvent(QMouseEvent *mouseEvent)
{
if (m_LevelWindow.IsFixed())
return;
m_MouseDown = true;
m_StartPos = mouseEvent->pos();
if (mouseEvent->button() == Qt::LeftButton)
{
if (mouseEvent->modifiers() == Qt::ControlModifier || mouseEvent->modifiers() == Qt::ShiftModifier)
{
m_CtrlPressed = true;
}
else
{
m_CtrlPressed = false;
}
m_Leftbutton = true;
}
else
m_Leftbutton = false;
mouseMoveEvent(mouseEvent);
}
void QmitkSliderLevelWindowWidget::resizeEvent(QResizeEvent *event)
{
m_MoveHeight = event->size().height() - 25;
Update();
}
void QmitkSliderLevelWindowWidget::mouseReleaseEvent(QMouseEvent *)
{
if (m_LevelWindow.IsFixed())
return;
m_MouseDown = false;
}
void QmitkSliderLevelWindowWidget::Update()
{
int rectWidth;
if (m_ScaleVisible)
{
rectWidth = 17;
setMinimumSize(QSize(50, 50));
setMaximumSize(QSize(50, 2000));
setSizePolicy(QSizePolicy(QSizePolicy::Minimum, QSizePolicy::Expanding));
}
else
{
rectWidth = 26;
setMinimumSize(QSize(40, 50));
setMaximumSize(QSize(50, 2000));
setSizePolicy(QSizePolicy(QSizePolicy::Minimum, QSizePolicy::Expanding));
}
mitk::ScalarType mr = m_LevelWindow.GetRange();
if (mr < 1e-9)
mr = 1e-9;
mitk::ScalarType fact = m_MoveHeight / mr;
mitk::ScalarType rectHeight = m_LevelWindow.GetWindow() * fact;
if (rectHeight < 15)
rectHeight = 15;
if (m_LevelWindow.GetLowerWindowBound() < 0)
m_Rect.setRect(2,
static_cast<int>(m_MoveHeight - (m_LevelWindow.GetUpperWindowBound() - m_LevelWindow.GetRangeMin()) * fact),
rectWidth,
static_cast<int>(rectHeight));
else
m_Rect.setRect(2,
static_cast<int>(m_MoveHeight - (m_LevelWindow.GetUpperWindowBound() - m_LevelWindow.GetRangeMin()) * fact),
rectWidth,
static_cast<int>(rectHeight));
QWidget::repaint();
}
void QmitkSliderLevelWindowWidget::contextMenuEvent(QContextMenuEvent *)
{
m_Contextmenu->SetLevelWindowManager(m_Manager.GetPointer());
auto contextMenu = new QMenu(this);
Q_CHECK_PTR(contextMenu);
if (m_ScaleVisible)
contextMenu->addAction(tr("Hide Scale"), this, SLOT(HideScale()));
else
contextMenu->addAction(tr("Show Scale"), this, SLOT(ShowScale()));
contextMenu->addSeparator();
m_Contextmenu->GetContextMenu(contextMenu);
// Fix: Bug #13327 we need to reset the m_MouseDown value
// otherwise the cursor is not correctly restored afterwards
m_MouseDown = false;
}
void QmitkSliderLevelWindowWidget::HideScale()
{
m_ScaleVisible = false;
Update();
}
void QmitkSliderLevelWindowWidget::ShowScale()
{
m_ScaleVisible = true;
Update();
}
void QmitkSliderLevelWindowWidget::SetDataStorage(mitk::DataStorage *ds)
{
m_Manager->SetDataStorage(ds);
}
mitk::LevelWindowManager *QmitkSliderLevelWindowWidget::GetManager()
{
return m_Manager.GetPointer();
}