mouseevent.h

Go to the documentation of this file.

#ifndef mouseevent_h
#define mouseevent_h

/*+
________________________________________________________________________

 (C) dGB Beheer B.V.; (LICENSE) http://opendtect.org/OpendTect_license.txt
 Author:        K. Tingdahl
 Date:          September 2005
 RCS:           $Id$
________________________________________________________________________

-*/

#include "generalmod.h"
#include "keyenum.h"
#include "gendefs.h"
#include "geometry.h"
#include "position.h"
#include "trckeyvalue.h"


mExpClass(General) TabletInfo
{
    friend class        QtTabletEventFilter;

public:
                        TabletInfo();

    enum                EventType { None=0, Move=87, Press=92, Release=93,
                                    EnterProximity=171, LeaveProximity=172 };
    EventType           eventtype_;
                        // Use mouse event-type if possible. The two might
                        // mismatch because of a QTabletEvent bug for Linux.

    enum                PointerType { UnknownPointer, Pen, Cursor, Eraser };
    PointerType         pointertype_;

    enum                TabletDevice { NoDevice, Puck, Stylus, Airbrush,
                                       FourDMouse, RotationStylus };
    TabletDevice        device_;

    Geom::Point2D<int>  globalpos_;
    Geom::Point2D<int>  pos_;

    double              pressure_;
    double              rotation_;
    double              tangentialpressure_;

    od_int64            uniqueid_;

    int                 xtilt_;
    int                 ytilt_;
    int                 z_;

    int                 postPressTime() const;
    float               postPressDist() const;
    float               maxPostPressDist() const;

    static const TabletInfo*    currentState();

protected:

    int                 presstimestamp_;
    float               maxpostpressdist_;
    Geom::Point2D<int>  globalpresspos_;

    static TabletInfo&  latestState();  
    void                updatePressData();
};


mExpClass(General) MouseEvent
{
public:

                                MouseEvent( OD::ButtonState st=OD::NoButton,
                                            int xx=0, int yy=0, float aa=0 )
                                    : butstate_(st), pos_(xx,yy), angle_(aa)
                                    , pressed_(false), tabletinfo_(0)
                                {}

                                MouseEvent(const MouseEvent& me)
                                    : tabletinfo_(0)
                                { *this = me; }

                                ~MouseEvent();
    MouseEvent&                 operator=(const MouseEvent&);

    OD::ButtonState             buttonState() const     { return butstate_; }
    void                        setButtonState(const OD::ButtonState&);

    bool                        isPressed() const       { return pressed_; }
    void                        setPressed(bool yn)     { pressed_ = yn; }

    const Geom::Point2D<int>&   pos() const             { return pos_; }
    int                         x() const               { return pos_.x; }
    int                         y() const               { return pos_.y; }
    float                       angle() const           { return angle_; }

    bool                        leftButton() const;
    bool                        rightButton() const;
    bool                        middleButton() const;
    bool                        ctrlStatus() const;
    bool                        altStatus() const;
    bool                        shiftStatus() const;

    bool                        operator ==( const MouseEvent& ev ) const;
    bool                        operator !=( const MouseEvent& ev ) const
                                                        { return !(*this==ev); }

    TabletInfo*                 tabletInfo();
    const TabletInfo*           tabletInfo() const;
    void                        setTabletInfo(const TabletInfo*);

    static float                getDefaultTrackpadZoomFactor();
    static float                getDefaultMouseWheelZoomFactor();

protected:

    OD::ButtonState             butstate_;
    bool                        pressed_;
    Geom::Point2D<int>          pos_;
    float                       angle_;
    TabletInfo*                 tabletinfo_;
};

mExpClass(General) MouseEventHandler : public CallBacker
{
public:
                                MouseEventHandler();
                                ~MouseEventHandler();

    void                        triggerMovement(const MouseEvent&);
    void                        triggerButtonPressed(const MouseEvent&);
    void                        triggerButtonReleased(const MouseEvent&);
    void                        triggerDoubleClick(const MouseEvent&);
    void                        triggerWheel(const MouseEvent&);

    Notifier<MouseEventHandler> buttonPressed;
    Notifier<MouseEventHandler> buttonReleased;
    Notifier<MouseEventHandler> movement;
    Notifier<MouseEventHandler> doubleClick;
    Notifier<MouseEventHandler> wheelMove;

    bool                        hasEvent() const        { return event_; }
    const MouseEvent&           event() const           { return *event_; }
    bool                        isHandled() const       { return ishandled_; }
    void                        setHandled(bool yn)     { ishandled_ = yn; }

protected:

    void                        setEvent(const MouseEvent*);
    MouseEvent*                 event_;

    bool                        ishandled_;
};


mExpClass(General) MouseCursorExchange : public CallBacker
{
public:
                                MouseCursorExchange();
    mExpClass(General) Info
    {
    public:
                                Info(const TrcKeyValue&,
                                     float offset=mUdf(float));

        TrcKeyValue             trkv_;
        float                   offset_;
    };

    CNotifier<MouseCursorExchange,const Info&>  notifier;
};
    

mExpClass(General) GestureEvent
{
public:
                            GestureEvent( int xx, int yy, float sc, float angl )
                            : pos_(xx,yy),scale_(sc),angle_(angl)
                            {}
    
        
    const Geom::Point2D<int>&   pos() const         { return pos_; }
    int                         x() const           { return pos_.x; }
    int                         y() const           { return pos_.y; }
    float                       scale() const       { return scale_; }
    float                       angle() const       { return angle_; }

    enum                        State{ Started, Moving, Finished };
    State                       getState() const { return state_; }
    void                        setState(State st) { state_ = st; }

protected:

    Geom::Point2D<int>          pos_;
    float                       scale_;
    float                       angle_;
    State                       state_;
};


mExpClass(General) GestureEventHandler : public CallBacker
{
public:
                                GestureEventHandler();
                                ~GestureEventHandler();
    
   
    void                        triggerPinchEvent(
                                            const GestureEvent& pinchevnt);
    const GestureEvent*         getPinchEventInfo() const;
    bool                        isHandled() const       { return ishandled_; }
    void                        setHandled(bool yn)     { ishandled_ = yn; }

    Notifier<GestureEventHandler> pinchnotifier;

private:

    const GestureEvent*             currentevent_;
    bool                            ishandled_;
};


                            

#endif