- Your Widget Set For OpenGL

---

uwidget.hpp

/***************************************************************************
    LibUFO - UI For OpenGL
    copyright         : (C) 2001-2005 by Johannes Schmidt
    email             : schmidtjf at users.sourceforge.net
                             -------------------

    file              : include/ufo/widgets/uwidget.hpp
    begin             : Sun May 13 2001
    $Id: uwidget.hpp,v 1.31 2005/10/17 16:39:22 schmidtjf Exp $
 ***************************************************************************/

/***************************************************************************
 *  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 USA *
 ***************************************************************************/

#ifndef UWIDGET_HPP
#define UWIDGET_HPP

#include "../uobject.hpp"

#include <map>

// headers in util
#include "../util/ugeom.hpp"
#include "../util/uinsets.hpp"
//#include "../util/uhashmap.hpp"
#include "../util/ustring.hpp"
#include "../util/ucolor.hpp"
#include "../util/upalette.hpp"

#include "../ui/ustyle.hpp"

// headers in events
#include "../events/uevent.hpp"

// headers in layouts
#include "../layouts/ulayoutmanager.hpp"

// headers in signals
#include "../signals/ufo_signals.hpp"

//#include "../ukeystroke.hpp"

#define UFO_UI_CLASS(name) \
public:                    \
    virtual std::string getUIClassID() const { \
        return #name; \
    }

#define UFO_STYLE_TYPE(name) \
public:                    \
    virtual UStyle::ComponentElement getStyleType() const { \
        return name; \
    }

namespace ufo {

typedef std::map<std::string, UObject*> UPropertiesMap;


// forward declartions
class UColor;
class UFont;
class UBorder;
class UUIManager;
class UWidgetUI;
class URootPane;

class UPopupMenu;

class UDrawable;

class UInputMap;
class UKeyStroke;

class UWidgetUI;

class UContext;
class UUIManager;
class UGraphics;

class UEvent;
class UActionEvent;
class UFocusEvent;
class UKeyEvent;
class UMouseEvent;
class UMouseWheelEvent;
class UPropertyChangeEvent;
class UShortcutEvent;
class UWidgetEvent;

class UStyle;
class UStyleHints;
class UStyleManager;
class UStyleOption;
class UWidgetModel;

class UFO_EXPORT UWidget : public UObject {
    UFO_DECLARE_DYNAMIC_CLASS(UWidget)
    UFO_UI_CLASS(UWidgetUI)
    UFO_STYLE_TYPE(UStyle::CE_Widget)
private:
    friend class UWidgetUI;

public:  // Public types
    // keyboard input conditions
    enum InputCondition {
        WhenFocused = 1,
        WhenAncestorFocused = 2
    };
    enum EventState {
        NoEvents = 0x0000,
        MouseEvents = 0x0001,
        MouseMotionEvents = 0x0002,
        MouseWheelEvents = 0x0004,
        KeyEvents = 0x0008,
        WidgetEvents = 0x0010,
        FocusEvents = 0x0020
    };
public:
    UWidget();
    UWidget(ULayoutManager * layout);
    virtual ~UWidget();

    virtual bool isVisible() const;
    virtual void setVisible(bool v);

    void setClipping(bool b);
    bool hasClipping() const;

    bool isEnabled() const;
    void setEnabled(bool b);
    bool isOpaque() const;
    virtual void setOpaque(bool o);

    virtual bool isActive() const;

    virtual bool isInValidHierarchy() const;
    bool isValid() const;
    virtual void validate();
    virtual void validateSelf();

    virtual void invalidateSelf();
    void invalidate();

    void invalidateTree();



    int getX() const;
    int getY() const;
    int getWidth() const;
    int getHeight() const;
    void setLocation(int x, int y);
    void setLocation(const UPoint & p);
    virtual UPoint getLocation() const;

    void setSize(int w, int h);
    void setSize(const UDimension & d);
    virtual UDimension getSize() const;
    UDimension getInnerSize() const;

    virtual void setBounds(int x, int y, int w, int h);
    void setBounds(const URectangle & b);
    virtual URectangle getBounds() const;
    URectangle getInnerBounds() const;
    URectangle getRootBounds() const;
    URectangle getClipBounds() const;



    bool contains(int x, int y) const;
    bool contains(const UPoint & p) const;
    bool containsRootPoint(int x, int y) const;
    bool containsRootPoint(const UPoint  & p) const;

    UPoint pointToRootPoint(int x, int y) const;
    UPoint pointToRootPoint(const UPoint & p) const;

    UPoint rootPointToPoint(int x, int y) const;
    UPoint rootPointToPoint(const UPoint & p) const;

    UPoint getRootLocation() const;


    //
    // painting and UI methods
    //


    virtual void paint(UGraphics * g);

    void repaint();


    virtual UStyleManager * getStyleManager() const;

    UStyle * getStyle() const;
    void setStyle(UStyle * style);
    const UStyleHints * getStyleHints() const;
    void setStyleHints(UStyleHints * hints);

    void setCssType(const std::string & type);
    std::string getCssType() const;
    void setCssClass(const std::string & cssClass);
    std::string getCssClass() const;

    UContext * getContext() const;

    void setContext(UContext * context);

    UUIManager * getUIManager() const;

    UGraphics * getGraphics() const;


    //
    // several attribute methods
    //

    //
    // style hints
    //
    float getOpacity() const;
    virtual void setOpacity(float f);

    void setPalette(const UPalette & palette);
    const UPalette & getPalette() const;

    void setBackgroundColor(const UColor & col);
    const UColor & getBackgroundColor() const;

    void setForegroundColor(const UColor & col);
    const UColor & getForegroundColor() const;

    bool hasBackground() const;
    void setBackground(UDrawable * tex);
    UDrawable * getBackground() const;

    void setFont(const UFont & font);
    const UFont & getFont() const;
    void setBorder(BorderType borderType);
    BorderType getBorder() const;


    void setMargin(const UInsets & margin);
    void setMargin(int top, int left, int bottom, int right);

    const UInsets & getMargin() const;

    virtual UInsets getInsets() const;


    void setMinimumSize(const UDimension & minimumSize);
    UDimension getMinimumSize() const;

    void setPreferredSize(const UDimension & preferredSize);

    void setMaximumSize(const UDimension & maximumSize);
    UDimension getMaximumSize() const;

    void setHorizontalAlignment(Alignment alignX);
    Alignment getHorizontalAlignment() const;
    void setVerticalAlignment(Alignment alignY);
    Alignment getVerticalAlignment() const;

    void setDirection(Direction dir);
    Direction getDirection() const;
    void setOrientation(Orientation orientation);
    Orientation getOrientation() const;

    //
    // generic methods
    //

    virtual bool isFocused() const;
    virtual bool isChildFocused() const;
    virtual bool isAncestorFocused() const;
    virtual UWidget * requestFocus();
    virtual bool releaseFocus();

    virtual bool isFocusable() const;
    virtual void setFocusable(bool focusable);

    static UWidget * getFocusedWidget();

    bool hasMouseFocus() const;

    static UWidget * getMouseFocusWidget();


    void dispatchEvent(UEvent * e);





    void setPopupMenu(UPopupMenu * popupMenu);
    virtual UPopupMenu * getPopupMenu() const;


    virtual bool remove(UWidget * w);
    virtual bool remove(unsigned int n);
    virtual UWidget * removeAndReturn(unsigned int n);
    virtual unsigned int removeAll();
    void add(UWidget * w, int index = -1);
    void add(UWidget * w, UObject * constraints, int index = -1);
    void add(UWidget * w, const UObject * constraints, int index = -1);


    virtual URootPane * getRootPane(bool topmost = false) const;

    UWidget * getParent() const;



    int getIndexOf(const UWidget * w) const;
    void setIndexOf(UWidget * w, int index);
    UWidget * getWidget(unsigned int n) const;
    UWidget * getWidgetAt(int x, int y) const;
    virtual UWidget * getWidgetAt(const UPoint & p) const;
    UWidget * getVisibleWidgetAt(int x, int y) const;
    virtual UWidget * getVisibleWidgetAt(const UPoint & p) const;

    unsigned int getWidgetCount() const;

    const std::vector<UWidget*> & getWidgets() const;
    std::vector<UWidget*> & getWidgets();



    ULayoutManager * getLayout() const;
    void setLayout(ULayoutManager * layout);

    virtual UDimension getPreferredSize() const;
    virtual UDimension getPreferredSize(const UDimension & maxSize) const;


    void put(const std::string & key, UObject * value);
    //void put(const std::string & key, int value);
    void put(const std::string & key, const std::string & value);
    UObject * get(const std::string & key) const;
    std::string getString(const std::string & key) const;

    UInputMap * getInputMap(InputCondition conditionA = WhenFocused);
    void setInputMap(UInputMap * newInputMapA,
        InputCondition conditionA = WhenFocused);

    void setEventState(UEvent::Type type, bool b);
    bool isEventEnabled(UEvent::Type type) const;

    const UWidgetModel * getModel() const;

    void grabShortcut(const UKeyStroke & stroke);
    void releaseShortcut(const UKeyStroke & stroke);
    void releaseAllShortcuts();

protected: // Overrides UObject
    virtual std::ostream & paramString(std::ostream & os) const;

protected:  // Protected methods
    virtual void addImpl(UWidget * w, UObject * constraints, int index);
    virtual bool removeImpl(int index);

    virtual void addedToHierarchy();
    virtual void removedFromHierarchy();

    void doLayout();

    virtual void paintWidget(UGraphics * g);
    virtual void paintBorder(UGraphics * g);
    virtual void paintChildren(UGraphics * g);


    virtual void processEvent(UEvent * e);

    virtual void processMouseEvent(UMouseEvent * e);
    virtual void processMouseWheelEvent(UMouseWheelEvent * e);
    virtual void processKeyEvent(UKeyEvent * e);
    virtual void processShortcutEvent(UShortcutEvent * e);
    virtual void processFocusEvent(UFocusEvent * e);
    virtual void processWidgetEvent(UWidgetEvent * e);

    virtual void processStyleHintChange(uint32_t styleHint);
    virtual void processStateChangeEvent(uint32_t state);


    bool firePropertyChangeEvent(const std::string & prop,
            UObject * oldValue, UObject * newValue);

    bool fireMouseEvent(UMouseEvent * e);

    bool fireKeyEvent(UKeyEvent * e);

    bool fireFocusEvent(UFocusEvent * e);
    bool fireWidgetEvent(UWidgetEvent * e);

    bool notifyKeyBindingAction(const UKeyStroke & ks, UKeyEvent * e,
        InputCondition condition);
    virtual bool processKeyBindings(UKeyEvent * e);

    void resetFocus();

    virtual UDimension getContentsSize(const UDimension & maxSize) const;
    void detachStyleHints();

public:  // Protected methods
    bool testState(uint32_t state) const;
    void setState(uint32_t state, bool b = true);
    void setStates(uint32_t states);
    uint32_t getStates() const;

private:
    void setChildrenVisible(bool b);
    void setChildrenEnabled(bool b);

protected:  // Protected static attributes
    static UWidget * sm_inputFocusWidget;
    static UWidget * sm_mouseFocusWidget;
    static UWidget * sm_dragWidget;

protected:  // Protected attributes
    UContext * m_context;

    UWidgetModel * m_model;

private:  // Private attributes
    //
    // flags
    //

    uint32_t m_isVisible: 1;
    uint32_t m_hasClipping: 1;
    uint32_t m_isEnabled: 1;
    //uint16_t m_isOpaque: 1;
    uint32_t m_isFocusable: 1;
    uint32_t m_isInValidHierarchy: 1;
    uint32_t m_hasInvalidLayout : 1;
    uint32_t m_styleHintsDetached : 1;

    //
    // flags for caching
    //
    uint32_t m_eventState;

    //
    // general variables
    //

    UWidget * m_parent;

    std::vector<UWidget*> m_children;

    ULayoutManager * m_layout;

    UPopupMenu * m_popupMenu;

    //
    // style hints
    //
    std::string m_cssType;
    std::string m_cssClass;
    mutable UStyle * m_style;
    mutable UStyleHints * m_styleHints;

    //
    // size hints
    //

    URectangle m_bounds;
    mutable URectangle m_clipBounds;
    mutable UPoint m_cachedRootLocation;
    mutable UDimension m_cachedPreferredSize;

    //const UColor * m_bgColor;
    //const UColor * m_fgColor;

    UPropertiesMap m_properties;

    UInputMap * m_inputMap;
    UInputMap * m_ancestorInputMap;

public: // Public Signals
    // Mouse event signals
    USignal1<UMouseEvent*> & sigMouseEntered();
    USignal1<UMouseEvent*> & sigMouseExited();

    USignal1<UMouseEvent*> & sigMouseMoved();
    USignal1<UMouseEvent*> & sigMouseDragged();

    USignal1<UMouseEvent*> & sigMousePressed();
    USignal1<UMouseEvent*> & sigMouseReleased();
    USignal1<UMouseEvent*> & sigMouseClicked();

    USignal1<UMouseWheelEvent*> & sigMouseWheel();


    // Key event signals
    USignal1<UKeyEvent*> & sigKeyPressed();
    USignal1<UKeyEvent*> & sigKeyReleased();
    USignal1<UKeyEvent*> & sigKeyTyped();

    // Widget event signals
    USignal1<UWidgetEvent*> & sigWidgetMoved();
    USignal1<UWidgetEvent*> & sigWidgetResized();
    USignal1<UWidgetEvent*> & sigWidgetShown();
    USignal1<UWidgetEvent*> & sigWidgetHidden();

    USignal1<UWidgetEvent*> & sigWidgetAdded();
    USignal1<UWidgetEvent*> & sigWidgetRemoved();

    // Focus event signals
    USignal1<UFocusEvent*> & sigFocusGained();
    USignal1<UFocusEvent*> & sigFocusLost();

private: // Private Signals
    // mouse signals
    USignal1<UMouseEvent*> m_sigMouseEntered;
    USignal1<UMouseEvent*> m_sigMouseExited;

    USignal1<UMouseEvent*> m_sigMouseMoved;
    USignal1<UMouseEvent*> m_sigMouseDragged;

    USignal1<UMouseEvent*> m_sigMousePressed;
    USignal1<UMouseEvent*> m_sigMouseReleased;
    USignal1<UMouseEvent*> m_sigMouseClicked;

    USignal1<UMouseWheelEvent*> m_sigMouseWheel;

    // key signals
    USignal1<UKeyEvent*> m_sigKeyPressed;
    USignal1<UKeyEvent*> m_sigKeyReleased;
    USignal1<UKeyEvent*> m_sigKeyTyped;

    // widget signals
    USignal1<UWidgetEvent*> m_sigWidgetMoved;
    USignal1<UWidgetEvent*> m_sigWidgetResized;
    USignal1<UWidgetEvent*> m_sigWidgetShown;
    USignal1<UWidgetEvent*> m_sigWidgetHidden;

    USignal1<UWidgetEvent*> m_sigWidgetAdded;
    USignal1<UWidgetEvent*> m_sigWidgetRemoved;

    // focus signals
    USignal1<UFocusEvent*> m_sigFocusGained;
    USignal1<UFocusEvent*> m_sigFocusLost;
};


//
// inline implementation
//

// Mouse Motion event signals
inline USignal1<UMouseEvent*> &
UWidget::sigMouseEntered() {
    setEventState(UEvent::MouseEntered, true);
    return m_sigMouseEntered;
}
inline USignal1<UMouseEvent*> &
UWidget::sigMouseExited() {
    setEventState(UEvent::MouseExited, true);
    return m_sigMouseExited;
}
inline USignal1<UMouseEvent*> &
UWidget::sigMouseMoved() {
    setEventState(UEvent::MouseMoved, true);
    return m_sigMouseMoved;
}
inline USignal1<UMouseEvent*> &
UWidget::sigMouseDragged() {
    setEventState(UEvent::MouseDragged, true);
    return m_sigMouseDragged;
}

// Mouse event signals
inline USignal1<UMouseEvent*> &
UWidget::sigMousePressed() {
    setEventState(UEvent::MousePressed, true);
    return m_sigMousePressed;
}
inline USignal1<UMouseEvent*> &
UWidget::sigMouseReleased() {
    setEventState(UEvent::MouseReleased, true);
    return m_sigMouseReleased;
}
inline USignal1<UMouseEvent*> &
UWidget::sigMouseClicked() {
    setEventState(UEvent::MouseClicked, true);
    return m_sigMouseClicked;
}

inline USignal1<UMouseWheelEvent*> &
UWidget::sigMouseWheel() {
    setEventState(UEvent::MouseWheel, true);
    return m_sigMouseWheel;
}

// Key event signals
inline USignal1<UKeyEvent*> &
UWidget::sigKeyPressed() {
    setEventState(UEvent::KeyPressed, true);
    return m_sigKeyPressed;
}
inline USignal1<UKeyEvent*> &
UWidget::sigKeyReleased() {
    setEventState(UEvent::KeyReleased, true);
    return m_sigKeyReleased;
}
inline USignal1<UKeyEvent*> &
UWidget::sigKeyTyped() {
    setEventState(UEvent::KeyTyped, true);
    return m_sigKeyTyped;
}

// Widget event signals
inline USignal1<UWidgetEvent*> &
UWidget::sigWidgetMoved() {
    setEventState(UEvent::WidgetMoved, true);
    return m_sigWidgetMoved;
}
inline USignal1<UWidgetEvent*> &
UWidget::sigWidgetResized() {
    setEventState(UEvent::WidgetResized, true);
    return m_sigWidgetResized;
}
inline USignal1<UWidgetEvent*> &
UWidget::sigWidgetShown() {
    setEventState(UEvent::WidgetShown, true);
    return m_sigWidgetShown;
}
inline USignal1<UWidgetEvent*> &
UWidget::sigWidgetHidden() {
    setEventState(UEvent::WidgetHidden, true);
    return m_sigWidgetHidden;
}
inline USignal1<UWidgetEvent*> &
UWidget::sigWidgetAdded() {
    return m_sigWidgetAdded;
}
inline USignal1<UWidgetEvent*> &
UWidget::sigWidgetRemoved() {
    return m_sigWidgetRemoved;
}

// Focus event signals
inline USignal1<UFocusEvent*> &
UWidget::sigFocusGained() {
    setEventState(UEvent::FocusGained, true);
    return m_sigFocusGained;
}
inline USignal1<UFocusEvent*> &
UWidget::sigFocusLost() {
    setEventState(UEvent::FocusLost, true);
    return m_sigFocusLost;
}



//
// inline position
//

inline int
UWidget::getX() const {
    return m_bounds.x;
}
inline int
UWidget::getY() const {
    return m_bounds.y;
}
inline int
UWidget::getWidth() const {
    return m_bounds.w;
}
inline int
UWidget::getHeight() const {
    return m_bounds.h;
}

inline void
UWidget::setLocation(int x, int y) {
    setBounds(x, y, m_bounds.w, m_bounds.h);
}
inline void
UWidget::setLocation(const UPoint & p) {
    setLocation(p.x, p.y);
}
inline UPoint
UWidget::getLocation() const {
    return UPoint(m_bounds.x, m_bounds.y);
}

inline void
UWidget::setSize(int w, int h) {
    setBounds(m_bounds.x, m_bounds.y, w, h);
}
inline void
UWidget::setSize(const UDimension & d) {
    setSize(d.w, d.h);
}
inline UDimension
UWidget::getSize() const {
    return UDimension(m_bounds.w, m_bounds.h);
}
inline UDimension
UWidget::getInnerSize() const {
    UDimension ret(getSize());
    return ret - getInsets();
}

inline void
UWidget::setBounds(const URectangle & b) {
    setBounds(b.x, b.y, b.w, b.h);
}
inline URectangle
UWidget::getInnerBounds() const {
    URectangle ret(0, 0, getWidth(), getHeight());
    return ret - getInsets();
}
inline URectangle
UWidget::getRootBounds() const {
    return URectangle(getRootLocation(), getSize());
}


inline bool
UWidget::contains(int x, int y) const {
    return (x >= 0 && x < getWidth() && y >= 0 && y < getHeight());
}

inline bool
UWidget::contains(const UPoint & p) const {
    return (p.x >= 0 && p.x < getWidth() && p.y >= 0 && p.y < getHeight());
}

inline UPoint
UWidget::pointToRootPoint(const UPoint & p) const {
    return (p + getRootLocation());
}

inline UPoint
UWidget::pointToRootPoint(int x, int y) const {
    return pointToRootPoint(UPoint(x, y));
}

inline UPoint
UWidget::rootPointToPoint(const UPoint & p) const {
    return (p - getRootLocation());
}

inline UPoint
UWidget::rootPointToPoint(int x, int y) const {
    return rootPointToPoint(UPoint(x, y));
}

inline bool
UWidget::containsRootPoint(int x, int y) const {
    return contains(rootPointToPoint(x, y));
}

inline bool
UWidget::containsRootPoint(const UPoint & p) const {
    return contains(rootPointToPoint(p));
}


inline void
UWidget::add(UWidget * w, int index) {
    addImpl(w, NULL, index);
}
inline void
UWidget::add(UWidget * w, UObject * constraints, int index) {
    addImpl(w, constraints, index);
}

} // namespace ufo

#endif // UWIDGET_HPP

---