Changeset 8127 in ntrip for trunk/BNC/qwt/qwt_magnifier.cpp

Timestamp:

May 10, 2017, 3:20:54 PM (7 years ago)

Author:

stoecker

Message:

update qwt and qwtpolar, many QT5 fixes (unfinished)

File:

• trunk/BNC/qwt/qwt_magnifier.cpp (modified) (18 diffs)

trunk/BNC/qwt/qwt_magnifier.cpp

@@ -19 +19 @@
         isEnabled( false ),
         wheelFactor( 0.9 ),
-        wheelButtonState( Qt::NoButton ),
+        wheelModifiers( Qt::NoModifier ),
         mouseFactor( 0.95 ),
         mouseButton( Qt::RightButton ),
-        mouseButtonState( Qt::NoButton ),
+        mouseButtonModifiers( Qt::NoModifier ),
         keyFactor( 0.9 ),
         zoomInKey( Qt::Key_Plus ),
+        zoomInKeyModifiers( Qt::NoModifier ),
         zoomOutKey( Qt::Key_Minus ),
-        zoomInKeyModifiers( Qt::NoModifier ),
         zoomOutKeyModifiers( Qt::NoModifier ),
         mousePressed( false )
@@ -35 +35 @@
 
     double wheelFactor;
-    int wheelButtonState;
+    Qt::KeyboardModifiers wheelModifiers;
 
     double mouseFactor;
-    int mouseButton;
-    int mouseButtonState;
+
+    Qt::MouseButton mouseButton;
+    Qt::KeyboardModifiers mouseButtonModifiers;
 
     double keyFactor;
+
     int zoomInKey;
+    Qt::KeyboardModifiers zoomInKeyModifiers;
+
     int zoomOutKey;
-    int zoomInKeyModifiers;
-    int zoomOutKeyModifiers;
+    Qt::KeyboardModifiers  zoomOutKeyModifiers;
 
     bool mousePressed;
@@ -109 +112 @@
    The wheel factor defines the ratio between the current range
    on the parent widget and the zoomed range for each step of the wheel.
+
+   Use values > 1 for magnification (i.e. 2.0) and values < 1 for
+   scaling down (i.e. 1/2.0 = 0.5). You can use this feature for
+   inverting the direction of the wheel.
+
    The default value is 0.9.
 
@@ -130 +138 @@
 
 /*!
-   Assign a mandatory button state for zooming in/out using the wheel.
-   The default button state is Qt::NoButton.
-
-   \param buttonState Button state
-   \sa wheelButtonState()
-*/
-void QwtMagnifier::setWheelButtonState( int buttonState )
-{
-    d_data->wheelButtonState = buttonState;
-}
-
-/*!
-   \return Wheel button state
-   \sa setWheelButtonState()
-*/
-int QwtMagnifier::wheelButtonState() const
-{
-    return d_data->wheelButtonState;
+   Assign keyboard modifiers for zooming in/out using the wheel.
+   The default modifiers are Qt::NoModifiers.
+
+   \param modifiers Keyboard modifiers
+   \sa wheelModifiers()
+*/
+void QwtMagnifier::setWheelModifiers( Qt::KeyboardModifiers modifiers )
+{
+    d_data->wheelModifiers = modifiers;
+}
+
+/*!
+   \return Wheel modifiers
+   \sa setWheelModifiers()
+*/
+Qt::KeyboardModifiers QwtMagnifier::wheelModifiers() const
+{
+    return d_data->wheelModifiers;
 }
 
@@ -179 +187 @@
 
    \param button Button
-   \param buttonState Button state
+   \param modifiers Keyboard modifiers
+
    \sa getMouseButton()
 */
-void QwtMagnifier::setMouseButton( int button, int buttonState )
+void QwtMagnifier::setMouseButton( 
+    Qt::MouseButton button, Qt::KeyboardModifiers modifiers )
 {
     d_data->mouseButton = button;
-    d_data->mouseButtonState = buttonState;
+    d_data->mouseButtonModifiers = modifiers;
 }
 
 //! \sa setMouseButton()
 void QwtMagnifier::getMouseButton(
-    int &button, int &buttonState ) const
+    Qt::MouseButton &button, Qt::KeyboardModifiers &modifiers ) const
 {
     button = d_data->mouseButton;
-    buttonState = d_data->mouseButtonState;
+    modifiers = d_data->mouseButtonModifiers;
 }
 
@@ -229 +239 @@
    \sa getZoomInKey(), setZoomOutKey()
 */
-void QwtMagnifier::setZoomInKey( int key, int modifiers )
+void QwtMagnifier::setZoomInKey( int key, 
+    Qt::KeyboardModifiers modifiers )
 {
     d_data->zoomInKey = key;
@@ -235 +246 @@
 }
 
-//! \sa setZoomInKey()
-void QwtMagnifier::getZoomInKey( int &key, int &modifiers ) const
+/*! 
+   \brief Retrieve the settings of the zoom in key
+
+   \param key Key code, see Qt::Key
+   \param modifiers Keyboard modifiers
+
+   \sa setZoomInKey()
+*/
+void QwtMagnifier::getZoomInKey( int &key, 
+    Qt::KeyboardModifiers &modifiers ) const
 {
     key = d_data->zoomInKey;
@@ -250 +269 @@
    \sa getZoomOutKey(), setZoomOutKey()
 */
-void QwtMagnifier::setZoomOutKey( int key, int modifiers )
+void QwtMagnifier::setZoomOutKey( int key, 
+    Qt::KeyboardModifiers modifiers )
 {
     d_data->zoomOutKey = key;
@@ -256 +276 @@
 }
 
-//! \sa setZoomOutKey()
-void QwtMagnifier::getZoomOutKey( int &key, int &modifiers ) const
+/*! 
+   \brief Retrieve the settings of the zoom out key
+
+   \param key Key code, see Qt::Key
+   \param modifiers Keyboard modifiers
+
+   \sa setZoomOutKey()
+*/
+void QwtMagnifier::getZoomOutKey( int &key, 
+    Qt::KeyboardModifiers &modifiers ) const
 {
     key = d_data->zoomOutKey;
@@ -266 +294 @@
   \brief Event filter
 
-  When isEnabled() the mouse events of the observed widget are filtered.
+  When isEnabled() is true, the mouse events of the
+  observed widget are filtered.
 
   \param object Object to be filtered
   \param event Event
+
+  \return Forwarded to QObject::eventFilter()
 
   \sa widgetMousePressEvent(), widgetMouseReleaseEvent(),
@@ -283 +314 @@
             case QEvent::MouseButtonPress:
             {
-                widgetMousePressEvent( ( QMouseEvent * )event );
+                widgetMousePressEvent( static_cast<QMouseEvent *>( event ) );
                 break;
             }
             case QEvent::MouseMove:
             {
-                widgetMouseMoveEvent( ( QMouseEvent * )event );
+                widgetMouseMoveEvent( static_cast<QMouseEvent *>( event ) );
                 break;
             }
             case QEvent::MouseButtonRelease:
             {
-                widgetMouseReleaseEvent( ( QMouseEvent * )event );
+                widgetMouseReleaseEvent( static_cast<QMouseEvent *>( event ) );
                 break;
             }
             case QEvent::Wheel:
             {
-                widgetWheelEvent( ( QWheelEvent * )event );
+                widgetWheelEvent( static_cast<QWheelEvent *>( event ) );
                 break;
             }
             case QEvent::KeyPress:
             {
-                widgetKeyPressEvent( ( QKeyEvent * )event );
+                widgetKeyPressEvent( static_cast<QKeyEvent *>( event ) );
                 break;
             }
             case QEvent::KeyRelease:
             {
-                widgetKeyReleaseEvent( ( QKeyEvent * )event );
+                widgetKeyReleaseEvent( static_cast<QKeyEvent *>( event ) );
                 break;
             }
@@ -325 +356 @@
 void QwtMagnifier::widgetMousePressEvent( QMouseEvent *mouseEvent )
 {
-    if ( ( mouseEvent->button() != d_data->mouseButton) 
-        || parentWidget() == NULL )
-    {
+    if ( parentWidget() == NULL )
         return;
-    }
-
-    if ( ( mouseEvent->modifiers() & Qt::KeyboardModifierMask ) !=
-        ( int )( d_data->mouseButtonState & Qt::KeyboardModifierMask ) )
+
+    if ( ( mouseEvent->button() != d_data->mouseButton ) ||
+        ( mouseEvent->modifiers() != d_data->mouseButtonModifiers ) )
     {
         return;
@@ -338 +366 @@
 
     d_data->hasMouseTracking = parentWidget()->hasMouseTracking();
+
     parentWidget()->setMouseTracking( true );
     d_data->mousePos = mouseEvent->pos();
@@ -393 +422 @@
 void QwtMagnifier::widgetWheelEvent( QWheelEvent *wheelEvent )
 {
-    if ( ( wheelEvent->modifiers() & Qt::KeyboardModifierMask ) !=
-        ( int )( d_data->wheelButtonState & Qt::KeyboardModifierMask ) )
+    if ( wheelEvent->modifiers() != d_data->wheelModifiers )
     {
         return;
@@ -411 +439 @@
          */
         double f = qPow( d_data->wheelFactor, 
-            qAbs( wheelEvent->delta() / 120 ) );
+            qAbs( wheelEvent->delta() / 120.0 ) );
 
         if ( wheelEvent->delta() > 0 )
@@ -428 +456 @@
 void QwtMagnifier::widgetKeyPressEvent( QKeyEvent *keyEvent )
 {
-    const int key = keyEvent->key();
-    const int state = keyEvent->modifiers();
-
-    if ( key == d_data->zoomInKey &&
-        state == d_data->zoomInKeyModifiers )
+    if ( keyEvent->key() == d_data->zoomInKey &&
+        keyEvent->modifiers() == d_data->zoomInKeyModifiers )
     {
         rescale( d_data->keyFactor );
     }
-    else if ( key == d_data->zoomOutKey &&
-        state == d_data->zoomOutKeyModifiers )
+    else if ( keyEvent->key() == d_data->zoomOutKey &&
+        keyEvent->modifiers() == d_data->zoomOutKeyModifiers )
     {
         rescale( 1.0 / d_data->keyFactor );
@@ -457 +482 @@
 QWidget *QwtMagnifier::parentWidget()
 {
-    if ( parent()->inherits( "QWidget" ) )
-        return ( QWidget * )parent();
-
-    return NULL;
+    return qobject_cast<QWidget *>( parent() );
 }
 
@@ -466 +488 @@
 const QWidget *QwtMagnifier::parentWidget() const
 {
-    if ( parent()->inherits( "QWidget" ) )
-        return ( const QWidget * )parent();
-
-    return NULL;
-}
-
+    return qobject_cast<const QWidget *>( parent() );
+}
+