faithcore/faith/widget.h

Go to the documentation of this file.

#ifndef KDE__WIDGET_H
#define KDE__WIDGET_H

#include <faith/string.h>
#include <faith/font.h>
#include <faith/application.h>
#include <faith/point.h>
#include <faith/rect.h>
#include <faith/color.h>
#include <faith/painter.h>
#include <faith/paintdevice.h>
#include <faith/colorgroup.h>
#include <faith/sizepolicy.h>

namespace Faith
{

class Event;
class MouseEvent;
class PaintEvent;
class Font;
class Layout;
class Style;

class FAITH_CORE_EXPORT Widget : public Object, public PaintDevice
{
        K_OBJECT
        
        friend class Faith::Layout;
        friend class Faith::Object;
        
        Handle mDrawable;
        Widget *mParentWidget;
        Rect mGeometry;
        ColorGroup mColorGroup;
        int mFlags;
        SizePolicy mSizePolicy;

        struct FaithWidgetPrivate;
        FaithWidgetPrivate *d;
        
public:
        enum Flags
        {
                DeleteOnClose = 1 << 0,
                TopLevel = 1 << 1,
                Popup = (1 << 2) | TopLevel,
                
                AvoidInit = 1<<3,

                RepaintNoErase = 1<<4
        };

        Widget(Widget *parent, const char *name=0, int wflags=0);

        virtual ~Widget();

        void setFlags(int flags);

        int flags() const { return mFlags; }

        virtual Handle handle() { return mDrawable; }
        
        Faith::String caption() const;
        
        Faith::Layout *layout();
        
public slots:
        virtual void show();
        
        virtual void hide();

        void setCaption(const Faith::String &title);

public:

        SizePolicy sizePolicy() const { return mSizePolicy; }
        void setSizePolicy(const SizePolicy &p) { mSizePolicy = p; }
        void setSizePolicy(SizePolicy::Policy h, SizePolicy::Policy v)
                 { mSizePolicy = SizePolicy(SizePolicy(h, v)); }
                
                
        Faith::Rect rect() const;
        
        Faith::Rect geometry() const;
        
        int width() const { return rect().width(); }
        int height() const { return rect().height(); }
        Faith::Size minimumSize() const;
        
        Faith::Size maximumSize() const;
        
        void setMinimumSize(const Faith::Size &size);
        
        void setMaximumSize(const Faith::Size &size);
        
        Faith::Size size() const { return rect().size(); }
        Faith::Point topLeft() const { return geometry().topLeft(); }

        void move(int x, int y);
        void resize(int w, int h);
        void setWidth(int w) { resize(w, height()); }
        void setHeight(int h) { resize(width(), h); }
        void move(const Faith::Point &pt) { move(pt.x(), pt.y()); }
        void resize(const Faith::Size &sz) { resize(sz.width(), sz.height()); }
        void setGeometry(int x, int y, int w, int h);
        void setGeometry(const Rect &r)
        {
                setGeometry(r.x(), r.y(), r.width(), r.height());
        }

        Faith::Widget *parentWidget();
        const Faith::Widget *parentWidget() const { return const_cast<Widget*>(this)->parentWidget(); }

        Faith::Point mapFromGlobal(const Faith::Point &pt) const;
        
        Faith::Point mapToGlobal(const Faith::Point &pt) const;

        Faith::Rect mapFromGlobal(const Faith::Rect &rect) const
        {
                Faith::Rect out = rect;
                out.setTopLeft(mapFromGlobal(out.topLeft()));
                return out;
        }

        Faith::Rect mapToGlobal(const Faith::Rect &rect) const
        {
                Faith::Rect out = rect;
                out.setTopLeft(mapToGlobal(out.topLeft()));
                return out;
        }

        // TODO
        const Faith::Pixmap *erasePixmap() const { return 0; }

        const ColorGroup &colorGroup() const { return mColorGroup; }

        void setPaletteBackgroundColor(const Color &color);
        
        Faith::Color paletteBackgroundColor() const;

        void setMouseTracking(bool on);
        
        void grabMouse();
        
        void releaseMouse();

        enum FocusMode
        {
                NoFocus,
                WeakFocus,
                ClickFocus
        };

        void setFocusMode(FocusMode mode);
        FocusMode focusMode() const { return mFocusMode; }
        
        bool hasFocus() const { return false; } // TODO
        
        bool isVisible() const;

        void setActiveWindow();
        
        bool topLevel() const;
        
        void repaint() { paintEvent(0); } // TODO!!!!!

public slots:
        void update();

signals:
        void hidden();
        
        void shown();
        
        void closed();
        
public:
        // TODO
        FontMetrics fontMetrics() const { return FontMetrics(faithapp->font()); }
        
        virtual Size sizeHint() const;

        Style *style();
        const Style *style() const { return const_cast<Widget*>(this)->style(); }
        
protected:
        virtual void polish(Style *) { }
        
#ifdef WITH_X11

        void faith_init(void *visual, int depth);
#endif

public: //events
        virtual bool event(Faith::Event *event);

        virtual void mousePressEvent(Faith::MouseEvent *) { }
        
        virtual void mouseReleaseEvent(Faith::MouseEvent *) { }
        
        virtual void mouseMoveEvent(Faith::MouseEvent *) { }
        
        virtual void keyPressEvent(Faith::KeyPressEvent *) { }
        
        virtual void paintEvent(Faith::PaintEvent *e);
        
        virtual void focusInEvent(Faith::FocusEvent *) { }
        
        virtual void focusOutEvent(Faith::FocusEvent *) { }
        
        virtual void enterEvent(Faith::Event *) { }
        
        virtual void leaveEvent(Faith::Event *) { }
        
        virtual void showEvent(Faith::Event *) { }
        
        virtual void hideEvent(Faith::Event *) { }
        
        virtual void closeEvent(Faith::CloseEvent *);
        
        virtual void resizeEvent(Faith::ResizeEvent *) { }

        virtual void moveEvent(Faith::MoveEvent *) { }

private:
        virtual Internal::Drawable *getDrawable();
        
        void invalidateSize();
        void childAdded(Faith::Widget *w);
        void childRemoved(Faith::Widget *w);
        void setLayout(Faith::Layout *layout);
        void layoutDeleted(Faith::Layout *layout);
        void beginLayoutUse();
        
private:
        FocusMode mFocusMode;
};

}

#endif

---