uevent.hpp

/************************************************************************
 *
 *  uevent.hpp
 *  Ubit GUI Toolkit - Version 6
 *  (C) 2009 | Eric Lecolinet | TELECOM ParisTech | http://www.enst.fr/~elc/ubit
 *
 * ***********************************************************************
 * COPYRIGHT NOTICE : 
 * THIS PROGRAM IS DISTRIBUTED WITHOUT ANY WARRANTY AND WITHOUT EVEN THE 
 * IMPLIED WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. 
 * YOU CAN REDISTRIBUTE IT AND/OR MODIFY IT UNDER THE TERMS OF THE GNU 
 * GENERAL PUBLIC LICENSE AS PUBLISHED BY THE FREE SOFTWARE FOUNDATION; 
 * EITHER VERSION 2 OF THE LICENSE, OR (AT YOUR OPTION) ANY LATER VERSION.
 * SEE FILES 'COPYRIGHT' AND 'COPYING' FOR MORE DETAILS.
 * ***********************************************************************/

#ifndef uevent_hpp
#define uevent_hpp  1
#include <ubit/ubox.hpp>
#include <ubit/ugeom.hpp>
#include <ubit/ukey.hpp>
namespace ubit {
  
  class UDataContext;
  
  class UEvent {
  public:
    UEvent(const UCond& c, UObject* source, UObject* aux = null);
    
    virtual ~UEvent();
    
    const UCond& getCond() const {return *cond;}
    virtual UObject* getSource() const {return source;}
    
    virtual UObject* getAux() const {return aux;}
    
    virtual UInputEvent*   toInputEvent()  {return null;}
    virtual UMouseEvent*   toMouseEvent()  {return null;}
    virtual UKeyEvent*     toKeyEvent()    {return null;}
    virtual UWheelEvent*   toWheelEvent()  {return null;}
    virtual UViewEvent*    toViewEvent()   {return null;}
    virtual UPaintEvent*   toPaintEvent()  {return null;}
    virtual UResizeEvent*  toResizeEvent() {return null;}  
    virtual UTimerEvent*   toTimerEvent()  {return null;}
    virtual UWinEvent*     toWinEvent()    {return null;}
    virtual UMessageEvent* toMessageEvent(){return null;}  
    virtual USysWMEvent*   toSysWMEvent()  {return null;}  
    virtual UUserEvent*    toUserEvent()   {return null;}
    
    void setCond(const UCond&);
    
  protected:
    const UCond* cond;  // event condition
    UObject* source;    // the object that produced this event
    UObject* aux;       // auxilliary data
  };
  

  // =============================================================================
  class UInputEvent : public UEvent, public UModifier {     
  public:
    UInputEvent(const UCond&, UView* source_view, UEventFlow*, 
                unsigned long when, int state);

     virtual UInputEvent* toInputEvent() {return this;}
    
    virtual UElem* getSource() const;  
    
    UView* getView() const {return source_view;}
    UView* getViewOf(const UBox& box) const;
    unsigned long getWhen() const {return when;}
    
    virtual int getModifiers() const;
    bool isShiftDown() const;
    bool isControlDown() const;
    bool isMetaDown() const;
    bool isAltDown() const;
    bool isAltGraphDown() const;
    
    UWin* getWin() const;
    
    UView* getWinView() const;
    
    UEventFlow* getFlow() const {return eflow;}
    UDisp* getDisp() const;
    bool dontCloseMenu() const {return modes.DONT_CLOSE_MENU;}
    
    // - - - Impl. - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
#ifndef NO_DOC
  protected:
    friend class UElem;
    friend class UEventFlow;
    friend class UView;
    friend class UFlowView;
    friend class UViewFind;
    
    struct Modes {
      unsigned PROPAGATE:1;
      unsigned IS_MDRAG:1;
      unsigned IS_FIRST_MDRAG:1;
      unsigned IS_BROWSING:1;
      unsigned DONT_CLOSE_MENU:1;
      unsigned SOURCE_IN_MENU:1;
    } modes;
        
    int state;
    unsigned long when;
    UView* source_view;    // the view that contains the mouse
    UEventFlow* eflow;     // the event flow that produced this event
    UElem* event_observer;
#endif
  };
  
  // =============================================================================
  class UMouseEvent : public UInputEvent {
  public:
    UMouseEvent(const UCond&, UView* source, UEventFlow*, unsigned long time, int state,
                const UPoint& pos, const UPoint& abs_pos, int btn);
    
    virtual UMouseEvent* toMouseEvent() {return this;}
    
    float getX() const {return pos.x;}
    
    float getY() const {return pos.y;}
    
    const UPoint& getPos() const {return pos;}
    
    const UPoint& getScreenPos() const {return abs_pos;}
    
    UPoint getPosIn(const UView& view) const;
    
    UPoint getPosIn(const UBox& parent_box) const;
    UPoint getPosAndViewIn(const UBox& parent, UView*& parent_view) const;
    int getClickCount() const {return click_count;}
    
    int getButton() const {return button;}
    int getButtons() const;
    void translatePos(float x, float y);
    
    void propagate() {modes.PROPAGATE = true;}
    
    void setFirstDrag(bool s)  {modes.IS_FIRST_MDRAG = s;}
    bool isFirstDrag() const   {return modes.IS_FIRST_MDRAG;}
    bool isBrowsing()  const   {return modes.IS_BROWSING;}
    
    // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    
    UStr* getStr();
    
    UStr* getStr(UDataContext&);
    
    UData* getData();
    
    UData* getData(UDataContext&);
    // - - - Impl. - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
#ifndef NO_DOC
  protected:
    friend class UEventFlow;
    friend class UElem;
    friend class UView;
    friend class UFlowView;
    int button, click_count;
    UPoint pos, abs_pos;
#endif
  };
  
  // =============================================================================
  class UWheelEvent : public UMouseEvent {
  public:
    enum {WHEEL_DELTA = 120};
    
    UWheelEvent(const UCond&, UView* source, UEventFlow*,
                unsigned long time, int state, 
                const UPoint& pos, const UPoint& abs_pos,
                int wheel_btn, int wheel_delta);
    
    virtual UWheelEvent* toWheelEvent() {return this;}
    
    bool isVertical() const {return (button & 1) == 0;}
    
    int getWheelDelta() const {return delta;}
  private:
    int delta;
  };
  
  // =============================================================================
  class UKeyEvent : public UInputEvent {
  public:
    UKeyEvent(const UCond&, UView* source, UEventFlow*, 
              unsigned long time, int state, 
              int keycode, short keychar);
    
    virtual UKeyEvent* toKeyEvent() {return this;}
    
    short getKeyChar() const {return keychar;}
    
    int getKeyCode() const {return keycode;}
    
    virtual void setKeyChar(short keychar);
    virtual void setKeyCode(int keycode);
    
  private:
    friend class UElem;
    int keycode;
    short keychar;
  };
  
  // =============================================================================
  class UViewEvent : public UEvent {
  public:
    UViewEvent(const UCond&, UView* source_view);
    virtual UViewEvent* toViewEvent() {return this;}
    
    UBox* getSource() const;
    
    UView* getView() const {return source_view;}
    
    UDisp* getDisp() const;
  protected:
    UView* source_view;
  };
  
  // =============================================================================
  class UPaintEvent : public UViewEvent {
  public:
    UPaintEvent(const UCond&, UView* source_view, const URect* win_clip = null);
    
    virtual UPaintEvent* toPaintEvent() {return this;}  

    bool isClipSet() {return is_clip_set;}
    
    void getClip(URect& r) const;
    const URect getClip() const {URect r; getClip(r); return r;}
    
#ifndef NO_DOC
    virtual bool setSourceAndProps(UView*);
    void setContext(UUpdateContext& c) {current_context = &c;}
    
  protected:
    friend class UBox;
    friend class UDisp;
    friend class UGraph;
    
    bool is_clip_set;   // is redraw_clip valid ?
    URect  redraw_clip;       // in window coordinates!
    UUpdateContext* current_context;
    UView* layout_view;
    
    virtual void setProps(const class UViewContext&);
#endif
  };
  
  // =============================================================================
  class UResizeEvent : public UViewEvent {
  public:
    UResizeEvent(const UCond&, UView* source_view);
    virtual UResizeEvent* toResizeEvent() {return this;}  
  };
    
  // =============================================================================
  
  class UWinEvent : public UEvent {
  public:
    UWinEvent(const UCond&, UView* source_view, int type, int state);
    
    virtual UWinEvent* toWinEvent() {return this;}
  
    UView* getView() const {return source_view;}    
    int getType()  const {return type;}
    int getState() const {return state;}
    
  private:
    UView* source_view;
    int type, state;
  };
  
  // =============================================================================
  class USysWMEvent : public UEvent {
  public:
    USysWMEvent(const UCond&, UView* source_view, void* system_event);
    
    virtual USysWMEvent* toSysWMEvent() {return this;}
    
    UView* getView() const {return source_view;}
    void* getSysEvent() {return sys_event;}
    
  private:
    UView* source_view;
    void* sys_event;
  };
  
  // =============================================================================
  class UMessageEvent : public UEvent {
  public:
    UMessageEvent(const UCond&, UMessagePort* port);
    
    virtual UMessageEvent* toMessageEvent() {return this;}
    
    //virtual UObject* getSource() const {return (UObject*)port;}
    
    const UStr* getMessage() const;
    
    UMessagePort* getMessagePort() const {return (UMessagePort*)source;}
    
  private:
    friend class UMessagePortMap;
    //UMessagePort* port;
  };
  
  // =============================================================================
  class UTimerEvent : public UEvent {
  public:
    UTimerEvent(const UCond&, UTimer* timer, unsigned long when);
    
    virtual UTimerEvent* toTimerEvent() {return this;}
    
    //virtual UObject* getSource() const {return (UObject*)timer;}
    UTimer* getTimer() const {return (UTimer*)source;}
    unsigned long getWhen() const {return when;}
    
  protected:
    //UTimer* timer;
    unsigned long when;
  };
  
  // =============================================================================
  class UUserEvent : public UEvent {
  public:
    UUserEvent(const UCond&, UObject* source, int type, void* data);
    
    virtual UUserEvent* toUserEvent() {return this;}
    
    //virtual UObject* getSource() const {return source;}
    int   getType() const {return type;}
    void* getData() const {return data;}
    
  private:
    //UObject* source;
    int type;
    void* data;  
  };
  
  /* ==================================================== [(c)Elc] ======= */
  class UDataContext {
  public:
    UDataContext();
    ~UDataContext();
    
    URect getBounds() const;
    
    // - - impl - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -   
# ifndef NO_DOC
  //private:
    friend class UBox;
    friend class UView;
    friend class UFlowView;
    friend class UEdit;
    friend class USelection;
     
    URect win_clip;
    // in the case of multine UStr objects, the region does not contain the entire
    // string but just the line that is beneath the mouse
    
    bool exact_match;
    // true if this data object is exactly located under the Mouse.
    // false if this data is the last data object before the Mouse position
    
    long strpos, strpos2;
    // strpos = position of the mouse in the string if data is an UStr.
    
    UChildIter it, it2;
    // points to the data object that is located under the mouse when calling 
    // UMouseEvent::getData() or UMouseEvent::getStr().
    
    UData* data;
    UView* source_view;
    UPoint win_eventpos;

    void set(UUpdateContext&, UData*, UChildIter data_iter, UChildIter end_iter, 
             const URect&, int _strpos, bool exact_match);
    void merge(UUpdateContext&, UData*, UChildIter data_iter, UChildIter end_iter, 
               const URect&, bool exact_match);    
# endif
  };
  
}
#endif