F:/KPlato/koffice/libs/flake/KoPointerEvent.h

Aller à la documentation de ce fichier.

/* This file is part of the KDE project

   Copyright (C) 2006 Thorsten Zachmann <zachmann@kde.org>
   Copyright (C) 2006 Casper Boemann Rasmussen <cbr@boemann.dk>
   Copyright (C) 2006 Thomas Zander <zander@kde.org>

   This library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Library General Public
   License as published by the Free Software Foundation; either
   version 2 of the License, or (at your option) any later version.

   This library is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   Library General Public License for more details.

   You should have received a copy of the GNU Library General Public License
   along with this library; see the file COPYING.LIB.  If not, write to
   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
 * Boston, MA 02110-1301, USA.
*/

#ifndef KOGFXEVENT_H
#define KOGFXEVENT_H

#include <QTabletEvent>
#include <QMouseEvent>
#include <QWheelEvent>

#include <koffice_export.h>

class FLAKE_EXPORT KoPointerEvent
{
public:
    KoPointerEvent( QMouseEvent *ev, const QPointF &pnt )
        : point( pnt )
        , m_tabletEvent( 0 )
        , m_mouseEvent( ev )
        , m_wheelEvent( 0 )
        , m_event( ev )
    {
    }

    KoPointerEvent( QTabletEvent *ev, const QPointF &pnt )
        : point( pnt )
        , m_tabletEvent( ev )
        , m_mouseEvent( 0 )
        , m_wheelEvent( 0 )
        , m_event( ev )
    {
    }    

    KoPointerEvent( QWheelEvent *ev, const QPointF &pnt )
        : point( pnt )
        , m_tabletEvent( 0 )
        , m_mouseEvent( 0 )
        , m_wheelEvent( ev )
        , m_event( ev )
    {
    }    
    void accept() { m_event->accept(); }

    void ignore() { m_event->ignore(); }

    Qt::KeyboardModifiers modifiers () const { return m_event->modifiers(); }

    bool isAccepted () const { return m_event->isAccepted(); }

    bool spontaneous () const { return m_event->spontaneous(); }

    Qt::MouseButton button () const 
        { 
            if (m_mouseEvent)
                return m_mouseEvent->button(); 
            else
                return Qt::NoButton;
        }

    Qt::MouseButtons buttons () const 
        { 
            if (m_mouseEvent)
                return m_mouseEvent->buttons(); 
            else if (m_wheelEvent)
                return m_wheelEvent->buttons();
            else
                return Qt::NoButton;
        }

    // Not needed, since we send the event to the right tool. Enable
    // as soon as there are tools that do different things depending
    // on the type of event. I don't think we checked in Krita tools
    // for these values.
    //
    //TabletDevice device () const 
    //PointerType pointerType () const 
    //qint64 uniqueId () const 
     
    const QPoint & globalPos()
        {
            if (m_mouseEvent)
                return m_mouseEvent->globalPos();
            else if (m_wheelEvent)
                return m_wheelEvent->globalPos();
            else
                return m_tabletEvent->globalPos();
        }

    const QPoint & pos () const 
        {
            if (m_mouseEvent)
                return m_mouseEvent->pos();
            else if (m_wheelEvent)
                return m_wheelEvent->pos();
            else
                return m_tabletEvent->pos();
        }

    qreal pressure () const 
        {
            if (m_tabletEvent) 
                return m_tabletEvent->pressure();
            else 
                return 1.0;
        }

    qreal rotation () const 
        {
            if (m_tabletEvent)
                return m_tabletEvent->rotation();
            else 
                return 0.0;
        }

    qreal tangentialPressure () const 
        {
            if (m_tabletEvent)
                return m_tabletEvent->tangentialPressure();
            else
                return 0.0;
        }

    int x () const 
        {
            if (m_tabletEvent)
                return m_tabletEvent->x();
            if (m_wheelEvent)
                return m_wheelEvent->x();
            else
                return m_mouseEvent->x();
        }
    
    int xTilt () const 
        {
            if (m_tabletEvent)
                return m_tabletEvent->xTilt();
            else
                return 0;
        }

    int y () const 
        {
            if (m_tabletEvent)
                return m_tabletEvent->y();
            if (m_wheelEvent)
                return m_wheelEvent->y();
            else
                return m_mouseEvent->y();
        }

    int yTilt () const 
        {
            if (m_tabletEvent)
                return m_tabletEvent->yTilt();
            else
                return 0;
        }

    int z () const
        {
            if (m_tabletEvent)
                return m_tabletEvent->z();
            else
                return 0;
        }

    int delta() const 
        {
            if (m_wheelEvent)
                return m_wheelEvent->delta();
            else
                return 0;
        }

    Qt::Orientation orientation() const
        {
            if (m_wheelEvent)
                return m_wheelEvent->orientation();
            else
                return Qt::Horizontal;
        }

    const QPointF &point;

private:
    QTabletEvent * m_tabletEvent;
    QMouseEvent * m_mouseEvent;
    QWheelEvent * m_wheelEvent;
    QInputEvent * m_event;
};

#endif /* KOGFXEVENT_H */

---