widget.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_WIDGET_H
#define WT_WIDGET_H

#include <wt/object.h>
#include <wt/layout.h>
#include <wt/pixmap.h>
#include <wt/rect.h>
#include <wt/region.h>
#include <wt/sizepolicy.h>
#include <wt/flags.h>
#include <wt/focusdata.h>

namespace Wt {
class PaintEvent;
class ResizeEvent;
class MoveEvent;
class LayoutHintEvent;
class ShowEvent;
class HideEvent;
class CloseEvent;
class Layout;
class Painter;
class Color;
class Font;

class Widget : public Object, public LayoutItem, public Pixmap {
public:
    typedef enum  {
        NoFocus = 0,
        TabFocus = 1 << 0,
        ClickFocus = 1 << 1,
        StrongFocus = TabFocus | ClickFocus,
        WheelFocus = 1 << 2 | StrongFocus
    } FocusPolicy;

    /// \todo document why we need explicit?
    explicit Widget(Widget *parent = 0, const std::string &name = "Widget::anon", int Wflags = 0);
    virtual ~Widget();

    /// parents are guaranteed to be widgets and not general wobjects
    Widget *parentWidget() const {
        return static_cast<Widget *>(parent());
    }

    Widget *topParentWidget() const {
        return static_cast<Widget *>(topParent());
    }

    void reparent(Widget *new_parent);

    // Excluding the window frame
    int width() const {
        return geometry().width();
    }
    int height() const {
        return geometry().height();
    }
    Size size() const {
        return geometry().size();
    }

    Rect rect() const {
        return Rect(0, 0, width(), height());
    }

    Point mapToGlobal(const Point & pos) const;
    Point mapFromGlobal(const Point & pos) const;
    Point mapToParent(const Point & pos) const;
    Point mapFromParent(const Point & pos) const;
    Region mapToGlobal(const Region & region) const;
    Region mapToParent(const Region & region) const;

    // change widget's state
    virtual void setBackgroundColor(const Color &c);
    const Color& backgroundColor() const;
    virtual void setForegroundColor(const Color &c);
    const Color& foregroundColor() const;

    virtual bool setBackgroundPixmapFlags(int flags, int alignment);
    virtual void setBackgroundPixmap(const Pixmap& pixmap,
                                     int flags = 0, int alignment = 0);
    const Pixmap& backgroundPixmap() const {
        return bg_pixmap_;
    }
    int backgroundPixmapFlags() const {
        return bg_flags;
    }
    int backgroundPixmapAlignment() const {
        return bg_alignment;
    }

    const Font& font() const;
    virtual void setFont(const Font& font);
    void unsetFont();

    /// event handling
    virtual bool event(Event *e);

    virtual void resize(int w, int h);
    void resize(const Size& size);
    virtual void move(int x, int y);
    void move(const Point& p);
    virtual void setGeometry(int x, int y, int w, int h);
    virtual void setGeometry(const Rect& r);

    static void update(Widget *w, const Region &region);

    void update (const Rect& r);
    void update(int x, int y, int w, int h);
    void update();
    void repaint(const Rect& r, bool erase = true);
    void repaint(const Region& r, bool erase = true);
    void repaint(int x, int y, int w, int h, bool erase = true);
    void repaint(bool erase);
    void repaint();
    void updateGeometry();

    void raise();
    void lower();

    bool isShown () const {
        return !hidden;
    }
    bool isHidden() const {
        return hidden;
    }
    bool isEmpty() const {
        return isHidden();
    }

    virtual Size sizeHint() const;
    virtual void setSizeHint(const Size& size);
    virtual Size minimumSize() const;
    virtual void setMinimumSize(const Size& size);
    virtual Size maximumSize() const;
    virtual void setMaximumSize(const Size& size);
    virtual SizePolicy sizePolicy() const;
    virtual void setSizePolicy(const SizePolicy& size_policy);
    virtual SizePolicy::ExpandData expanding() const;

    Layout *layout() const {
        return layout_;
    }

    void setLayout(Layout *layout);

    void erase(const Rect& r);
    void erase(const Region& r);
    void erase(int x, int y, int w, int h);
    void erase();

    void drawText(int x, int y, const std::string& text);
    void drawText(const Point& p, const std::string& text);

    Widget *childAt(const Point& p, bool self_include = false) const;
    Widget *childAt(int x, int y, bool self_include = false) const {
        return childAt(Point(x, y), self_include);
    }

    Widget *focusWidget() const {
        return focus_data_.focusWidget();
    }

    bool hasFocus() const {
        return (focusWidget() == this);
    }

    bool isFocusEnabled(int reason) const;
    virtual void setFocus(int reason);

    void grabKeyboard();
    void releaseKeyboard();
    static Widget *keyboardGrabber();

    void grabMouse();
    void releaseMouse();
    static Widget *mouseGrabber();

    virtual void hide();
    virtual void show();

    bool close();
    virtual bool close(bool destroy);

    void setHidden(bool do_hide = true);
    void setShown(bool do_show = true);

    virtual void enable();
    virtual void disable();

    void setEnabled(bool do_enable = true);
    void setDisabled(bool do_disable = true);

    /// public attributes
    WVar<bool> hidden;
    WVar<bool> enabled;
    WVar<bool> mouseTracking;
    WVar<int> focusPolicy;
    WVar<int> ownFont;

protected:
    /// event handling specialization
    virtual void mousePressEvent(MouseEvent *);
    virtual void mouseReleaseEvent(MouseEvent *);
    virtual void mouseDoubleClickEvent(MouseEvent *);
    virtual void mouseMoveEvent(MouseEvent *);
    virtual void wheelEvent(WheelEvent *);
    virtual void focusInEvent(FocusEvent *);
    virtual void focusOutEvent(FocusEvent *);
    virtual void keyPressEvent(KeyEvent *);
    virtual void keyReleaseEvent(KeyEvent *);
    virtual void enterEvent(Event *);
    virtual void leaveEvent(Event *);
    virtual void paintEvent(PaintEvent *);
    virtual void resizeEvent(ResizeEvent *);
    virtual void moveEvent(MoveEvent *);
    virtual void showEvent(ShowEvent *);
    virtual void hideEvent(HideEvent *);
    virtual void closeEvent(CloseEvent *);

    /// widget should be able to draw itself
    virtual void draw(Painter *p, const Region& region);

    bool autoerase() {
        return !(wflags_ & W::NoAutoErase);
    }

    bool autoclip() {
        return !(wflags_ & W::PaintUnclipped);
    }

    // on state change
    virtual void fontChange(const Font& oldFont);

    Signal01<void, Layout *> layoutChanged;

    void updateBackground();

    FocusData *focusData() const {
        return &focus_data_;
    }

    virtual bool focusNextPrevChild(bool next);

    void hiddenChanged(bool hidden_new);

    bool is_hidden(bool val) const;
    bool is_enabled(bool val) const;

private:
    int wflags_;
    bool need_redraw_;
    Pixmap bg_pixmap_;
    Pixmap bg_scaled_;
    int bg_flags;
    int bg_alignment;
    Painter *painter_;

    Layout *layout_;
    Size l_size_hint_;
    Size l_min_size_;
    Size l_max_size_;

    static FocusData focus_data_;
};

}
#endif // WT_WIDGET_H

---

Generated Fri Jul 28 19:23:01 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.