event.h

Go to the documentation of this file.

/*
  libwt - Vassilis Virvilis Toolkit - a widget library
  Copyright (C) 2006 Vassilis Virvilis <vasvir2@fastmail.fm>
 
  This library is free software; you can redistribute it and/or
  modify it under the terms of the GNU Lesser General Public
  License as published by the Free Software Foundation; either
  version 2.1 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
  Lesser General Public License for more details.
  
  You should have received a copy of the GNU Lesser General Public
  License along with this library; if not, write to the
  Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  Boston, MA  02111-1307, SA.
*/

#ifndef WT_EVENT_H
#define WT_EVENT_H

#include <wt/region.h>
#include <wt/trace.h>

namespace Wt {

class Object;

class Event {
public:
    /// events that are delivered per widget
    typedef enum {
        Nope,
        Timer,
        MouseButtonPress,
        MouseButtonRelease,
        MouseButtonDblClick,
        MouseMove,
        KeyPress,   //6
        KeyRelease,
        FocusIn,
        FocusOut,
        Enter,
        Leave,      //11
        Paint,
        Move,
        Resize,     //14
        Wheel,
        ChildInserted,  //16
        ChildRemoved,
        LayoutHint, //18
        Show,
        Hide,
        Close,
        User,
        MaxEvent
    } Type;

    ///
    Event(int type) : type_(type) {
        trace("event") << "Creating event " << this << std::endl;
    }
    ///
    virtual ~Event() {
        trace("event") << "Destroying event " << this << std::endl;
    }

    ///
    int type() const {
        return type_;
    }

private:
    int type_;
};

class TimerEvent : public Event {
public:
    TimerEvent(int timer_id)
            : Event(Timer),
    timer_id_(timer_id) {}

    int timerid() const {
        return timer_id_;
    }

private:
    int timer_id_;
};

class PaintEvent : public Event {
public:
    PaintEvent(const Rect& rect, bool erased = true)
            : Event(Paint), region_(rect), rect_(rect), erased_(erased) {}

    PaintEvent(const Region& region, bool erased = true)
            : Event(Paint), region_(region),
    rect_(region.boundingRect()), erased_(erased) {}

    const Region& region() const {
        return region_;
    }

    const Rect& rect() const {
        return rect_;
    }

    bool erased() const {
        return erased_;
    }

private:
    Region region_;
    Rect rect_;
    bool erased_;
};

class ResizeEvent : public Event {
public:
    ResizeEvent(const Size& size, const Size& oldsize)
            : Event(Resize), size_(size), oldsize_(oldsize) {}

    const Size& size() const {
        return size_;
    }

    const Size& oldSize() const {
        return oldsize_;
    }

private:
    Size size_;
    Size oldsize_;
};

class MoveEvent : public Event {
public:
    MoveEvent(const Point& pos, const Point& oldpos)
            : Event(Move), pos_(pos), oldpos_(oldpos) {}

    const Point& pos() const {
        return pos_;
    }

    const Point& oldPos() const {
        return oldpos_;
    }

private:
    Point pos_;
    Point oldpos_;
};

class LayoutHintEvent : public Event {
public:
    LayoutHintEvent()
            : Event(LayoutHint) {}
private:
};

class ShowEvent : public Event {
public:
    ShowEvent()
            : Event(Show) {}
private:
};

class HideEvent : public Event {
public:
    HideEvent()
            : Event(Hide) {}
private:
};

class ChildEvent : public Event {
public:
    ChildEvent(int type, Object *child)
            : Event(type),
        inserted_((ChildInserted == type) ? true : false),
    child_(child) {}

    Object *child() const {
        return child_;
    }

    bool inserted() const {
        return inserted_;
    }

    bool removed() const {
        return !inserted_;
    }

private:
    bool inserted_;
    Object *child_;
};

class CustomEvent : public Event {
public:
    CustomEvent(int event_offset = 0)
    : Event(User + event_offset) {
        // void comment to trick astyle
    }
};

class InputEvent : public Event {
public:
    InputEvent(int type, int state) :
            Event(type),
            state_(static_cast<ButtonState>(state)),
    accepted_(false) {}

    ButtonState state() const {
        return state_;
    }
    /// \todo fix stateAfter()
    ButtonState stateAfter() const {
        return state_;
    }
    bool isAccepted() const {
        return accepted_;
    }
    void accept() {
        accepted_ = true;
    }
    void ignore() {
        accepted_ = false;
    }

private:
    ButtonState state_;
    bool accepted_;
};

class MouseEvent : public InputEvent {
public:
    MouseEvent(int type, const Point& pos, int button, int state) :
            InputEvent(type, state),
            pos_(pos),
    button_(static_cast<ButtonState>(button)) {}
    MouseEvent(int type, const Point& pos,
               const Point& global_pos, int button, int state) :
            InputEvent(type, state),
            pos_(pos),
            global_pos_(global_pos),
    button_(static_cast<ButtonState>(button)) {}

    const Point& pos() const {
        return pos_;
    }
    const Point& globalPos() const {
        return global_pos_;
    }
    int x() const {
        return pos_.x();
    }
    int y() const {
        return pos_.y();
    }
    int globalX() const {
        return global_pos_.x();
    }
    int globalY() const {
        return global_pos_.y();
    }
    ButtonState button() const {
        return button_;
    }

private:
    Point pos_;
    Point global_pos_;
    ButtonState button_;
};

class WheelEvent : public MouseEvent {
public:
    WheelEvent(const Point& pos, int delta, int state) :
            MouseEvent(Wheel, pos, MidButton, state),
    delta_(delta) {}

    WheelEvent(const Point& pos, const Point& global_pos,
               int delta, int state) :
            MouseEvent(Wheel, pos, global_pos, MidButton, state),
    delta_(delta) {}

    int delta() const {
        return delta_;
    }
private:
    int delta_;
};

class KeyEvent : public InputEvent {
public:
    KeyEvent(int type, int key, int state) :
            InputEvent(type, state),
    key_(key) {}

    int key() const {
        return key_;
    };

    /// \todo ascii chars
    int ascii() const {
        return 0;
    }

    /// \todo unicode chars
    int text() const {
        return 0;
    }

    /// we receive one event for every autoreapeat
    /// so it's not possible to distinguish it
    bool isAutoRepeat() const {
        return false;
    }

    /// one char per event
    int count() const {
        return 1;
    }

private:
    int key_;
};

class FocusEvent : public Event {
public:
    typedef enum {
        Mouse,
        Tab,
        Backtab,
        ActiveWindow,
        Popup,
        Shortcut,
        Other
    } Reason;

    FocusEvent(int type, int reason = Other) :
            Event(type),
    reason_(reason) {}

    bool gotFocus() const {
        return type() == FocusIn;
    }

    bool lostFocus() const {
        return type() == FocusOut;
    }

    int reason() {
        return reason_;
    }

private:
    int reason_;
};

class CloseEvent : public Event {
public:
    CloseEvent()
            : Event(Close),
    accepted_(false) {}

    bool isAccepted() const {
        return accepted_;
    }
    void accept() {
        accepted_ = true;
    }
    void ignore() {
        accepted_ = false;
    }

private:
    bool accepted_;
};

}
#endif // WT_EVENT_H

---

Generated Fri Jul 28 19:23:00 2006.
Copyright © 1998-2003 by the respective authors.

This document is licensed under the terms of the GNU Free Documentation License and may be freely distributed under the conditions given by this license.