src/libs/gui_tk/gui_tk.h

Go to the documentation of this file.

#ifndef GUI__TOOLKIT_H
#define GUI__TOOLKIT_H

#define imin(x,y) ((x)<(y)?(x):(y))
#define imax(x,y) ((x)>(y)?(x):(y))
#define isign(x) (((x)<0?-1:1))

#ifdef _MSC_VER
typedef signed __int8   int8_t;
typedef signed __int16  int16_t;
typedef signed __int32  int32_t;
typedef unsigned __int8  uint8_t;
typedef unsigned __int16 uint16_t;
typedef unsigned __int32 uint32_t;
#else
#include <stdint.h>
#endif

#include <list>
#include <map>
#include <vector>
#include <typeinfo>
#include <string>
#include <iostream>

namespace GUI {

typedef uint32_t RGB;

namespace Color {
const RGB Transparent = 0x00ffffff;

const RGB Black = 0xff000000;

const RGB White = 0xffffffff;

const RGB AlphaMask = 0xff000000;

const int AlphaShift = 24;

const RGB RedMask = 0x00ff0000;

const RGB Red = Black|RedMask;

const int RedShift = 16;

const RGB GreenMask = 0x0000ff00;

const RGB Green = Black|GreenMask;

const int GreenShift = 8;

const RGB BlueMask = 0x000000ff;

const RGB Blue = Black|BlueMask;

const int BlueShift = 0;

const RGB Magenta = Red|Blue;

const RGB MagentaMask = RedMask|BlueMask;

const RGB Cyan = Green|Blue;

const RGB CyanMask = GreenMask|BlueMask;

const RGB Yellow = Red|Green;

const RGB YellowMask = RedMask|GreenMask;

const RGB Grey50 = 0xff808080;

extern RGB Background3D;

extern RGB Light3D;

extern RGB Shadow3D;

extern RGB Border;

extern RGB Text;

extern RGB Background;

extern RGB SelectionBackground;

extern RGB SelectionForeground;

extern RGB EditableBackground;

extern RGB Titlebar;

extern RGB TitlebarText;

extern RGB TitlebarInactive;

extern RGB TitlebarInactiveText;

static inline RGB rgba(unsigned int r, unsigned int g, unsigned int b, unsigned int a=0) {
        return (((r&255)<<RedShift)|((g&255)<<GreenShift)|((b&255)<<BlueShift)|((a&255)<<AlphaShift));
}

static inline unsigned int R(RGB val) { return ((val&Color::RedMask)>>Color::RedShift); }
static inline unsigned int G(RGB val) { return ((val&Color::GreenMask)>>Color::GreenShift); }
static inline unsigned int B(RGB val) { return ((val&Color::BlueMask)>>Color::BlueShift); }
static inline unsigned int A(RGB val) { return ((val&Color::AlphaMask)>>Color::AlphaShift); }

}

enum MouseButton { NoButton, Left, Right, Middle, WheelUp, WheelDown, WheelLeft, WheelRight };

typedef unsigned int Size;

typedef uint32_t Char;

typedef unsigned int Ticks;

class Key {
public:

        Char character;

        enum Special {
                None,
                F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12,
                Up, Down, Left, Right, Backspace, Tab, Backtab, Enter, Escape,
                Home, End, PageUp, PageDown, Insert, Delete, Menu,
                Print, Pause, Break, CapsLock, NumLock, ScrollLock,
                Alt, Ctrl, Shift, Windows
        } special;
        bool shift;
        bool ctrl;
        bool alt;

        bool windows;

        Key(GUI::Char character, Special special, bool shift, bool ctrl, bool alt, bool windows) :
                character(character), special(special),
                shift(shift), ctrl(ctrl), alt(alt), windows(windows) {}
};

class Drawable;
class String;

template <typename STR> class NativeString {
protected:
        friend class String;

        static void getString(String &dest, const STR &src)  { (void)dest; (void)src; STR::_this_string_type_is_not_supported_(); }

        static STR& getNative(const String &src) { (void)src; STR::_this_string_type_is_not_supported_();return*new STR(); }
};

template <typename STR> class NativeString<STR*> {
protected:
        friend class String;
        static void getString(String &dest, const STR *src);
        static STR* getNative(const String &src);
};

template <typename STR, Size N> class NativeString<STR[N]> : public NativeString<STR*> {};
template <typename STR, Size N> class NativeString<const STR[N]> : public NativeString<STR*> {};
template <typename STR> class NativeString<const STR*> : public NativeString<STR*> {};

struct ltvoid { bool operator()(const void* s1, const void* s2) const { return s1 < s2; } };

class Refcount {
public:
    /* NTS: Refcount starts at zero because there's so much of this damn code that expects to
     *      create UI elements with just "new Window blah blah" and for the class to delete it.
     *      This makes the transition to proper refcounting less painful and more gradual. */
    Refcount() : _refcount(0) { }
    virtual ~Refcount() {
        if (_refcount != 0) fprintf(stderr,"WARNING: GUI_TK::Refcount object %p refcount is nonzero (%d) on destructor\n",(void*)this,_refcount);
    }
public:
    int addref(void) {
        return ++_refcount;
    }
    int release(void) {
        int ref = --_refcount;

        if (ref < 0) fprintf(stderr,"WARNING: GUI_TK::Refcount object %p refcount is negative (%d) after release\n",(void*)this,_refcount);
        if (ref == 0) delete this;

        return ref;
    }
private:
    volatile int _refcount;
};

template <class C> class RefcountAuto : public Refcount {
public:
    RefcountAuto() : Refcount(), _ptr(NULL) { }
    RefcountAuto(C * const np) : _ptr(np) { if (_ptr != NULL) _ptr->addref(); }
    virtual ~RefcountAuto() { if (_ptr != NULL) _ptr->release(); }
public:
    C* operator=(C * const np) {
        if (_ptr != np) {
            C* _old = _ptr;
            _ptr = np;
            if (_ptr != NULL) _ptr->addref();
            if (_old != NULL) _old->release();
        }

        return _ptr;
    }
    bool operator==(const C * const np) const {
        return (_ptr == np);
    }
    bool operator!=(const C * const np) const {
        return !(*this == np);
    }
    bool operator!() const { /* ex: if (!ptr) ... equiv. if (ptr == NULL) */
        return (_ptr == NULL);
    }
    C* getptr(void) const {
        return _ptr;
    }
    C& operator*(void) const {
        return *_ptr;
    }
    C* operator->(void) const {
        return _ptr;
    }
private:
    C*              _ptr;
};

class String : public std::vector<Char> {
protected:
        template <typename STR> friend class NativeString;
        class Native { public: virtual ~Native() {}; };
        template <typename STR> class NativeArray: public Native {
                STR *data;
        public:
                NativeArray(STR *data) : data(data) {}
                virtual ~NativeArray() { delete[] data; }
        };
        template <typename STR> class NativeObject: public Native {
                STR *data;
        public:
                NativeObject(STR *data) : data(data) {}
                virtual ~NativeObject() { delete data; }
        };

private:
        mutable std::map<const class std::type_info *, Native *, ltvoid> strings;

protected:
        void addNative(Native *dest) const {
                const class std::type_info &type = typeid(dest);
                if (strings[&type] != NULL) delete strings[&type];
                strings[&type] = dest;
        }

public:
        template <typename STR> String(const STR& src) { NativeString<STR>::getString(*this, src); }

        template <class InputIterator> String(InputIterator a, InputIterator b) : std::vector<Char>(a,b) {}

        String(const String &src) : std::vector<Char>(src), strings() {};

        String() { }

        ~String() {
                for (std::map<const class std::type_info *, Native *, ltvoid>::iterator i = strings.begin(); i != strings.end(); ++i)
                        delete (*i).second;
        };


        template <typename T> operator T() const { return NativeString<T>::getNative(*this); }

        template <typename T> bool operator==(const T &src) const { return *this == String(src); }
        bool operator==(const String &src) const { return *(std::vector<Char>*)this == src; }

        template <typename T> bool operator!=(const T &src) const { return *this != String(src); }
        bool operator!=(const String &src) const { return *(std::vector<Char>*)this != src; }

    String& operator=(const String&) = default;
};

template <typename STR> void NativeString<STR*>::getString(String &dest, const STR* src) {
        Size strlen = 0;
        while (src[strlen]) strlen++;
        dest.resize(strlen);
        for (strlen = 0; src[(unsigned int)strlen]; strlen++) dest[(unsigned int)strlen] = (unsigned int)(sizeof(STR)==1?(unsigned char)src[strlen]:sizeof(STR)==2?(unsigned short)src[strlen]:src[strlen]);
}

template <typename STR> STR* NativeString<STR*>::getNative(const String &src) {
        Size strlen = (Size)src.size();
        STR* dest = new STR[strlen+1];
        dest[strlen] = 0;
        for (; strlen > 0; strlen--) dest[strlen-1] = src[strlen-1];
        src.addNative(new String::NativeArray<const STR>(dest));
        return dest;
}

template <> class NativeString<std::string*> {
protected:
        friend class String;
        static void getString(String &dest, const std::string *src) {
                Size strlen = (Size)src->length();
                dest.resize(strlen);
                for (Size i = 0; i< strlen; i++) dest[i] = (unsigned int)((*src)[i]);
        }
        static std::string* getNative(const String &src) {
                Size strlen = (Size)src.size();
                std::string* dest = new std::string();
                for (Size i = 0; i < strlen; i++) dest->append(1,src[i]);
                src.addNative(new String::NativeObject<std::string>(dest));
                return dest;
        }
};

template <> class NativeString<const std::string*> : public NativeString<std::string*> {};

template <> class NativeString<std::string> {
protected:
        friend class String;
        static void getString(String &dest, const std::string &src) {
                Size strlen = (Size)src.length();
                dest.resize(strlen);
                for (Size i = 0; i< strlen; i++) dest[i] = (unsigned int)src[i];
        }
        static std::string& getNative(const String &src) {
                Size strlen = (Size)src.size();
                std::string* dest = new std::string();
                for (Size i = 0; i < strlen; i++) dest->append(1,src[i]);
                src.addNative(new String::NativeObject<std::string>(dest));
                return *dest;
        }
};

template <> class NativeString<const std::string> : public NativeString<std::string> {};

class ToplevelWindow;
class Menu;
class TransientWindow;
class Screen;
class Window;

struct Window_Callback {
public:
                virtual void windowMoved(Window *win, int x, int y) = 0;
                virtual ~Window_Callback() {}
};


class Window : public Refcount {
protected:
        friend class ToplevelWindow;
        friend class TransientWindow;
    friend class WindowInWindow;
        friend class Menu;

        int width;
        int height;
        int x;
        int y;

        bool dirty;

        bool visible;

    bool tabbable;

        Window *const parent;


        Window  *mouseChild;

    bool transient;

    bool toplevel;

    bool mouse_in_window;
public:
    bool first_tabbable = false;

    bool last_tabbable = false;
protected:

        std::list<Window *> children;

        std::list<Window_Callback *> movehandlers;

        virtual void addChild(Window *child);

        virtual void removeChild(Window *child);

        void setDirty() { if (dirty) return; dirty = true; if (parent != NULL) parent->setDirty(); };

        virtual void setClipboard(const String &s) { parent->setClipboard(s); };

        virtual const String& getClipboard() { return parent->getClipboard(); };

        Window();

        virtual void focusChanged(bool gained) {
                if (children.size() > 0) children.back()->focusChanged(gained);
        }

public:

        void addWindowHandler(Window_Callback *handler) { movehandlers.push_back(handler); }

        void removeWindowHandler(Window_Callback *handler) { movehandlers.remove(handler); }

        Window(Window *parent, int x, int y, int w, int h);

        virtual ~Window();


        virtual void resize(int w, int h);
        virtual int getWidth() const { return width; }
        virtual int getHeight() const { return height; }


        virtual void move(int x, int y);
        virtual int getX() const { return x; }
        virtual int getY() const { return y; }
        virtual int getScreenX() const { return (parent == NULL?0:parent->getScreenX()+x); }
        virtual int getScreenY() const { return (parent == NULL?0:parent->getScreenY()+y); }

        virtual void paintAll(Drawable &d) const;

        virtual void paint(Drawable &d) const { (void)d; };


        virtual void setVisible(bool v) { visible = !!v; parent->setDirty(); if (!visible) mouse_in_window = false; }

        virtual bool isVisible() const { return (!parent || parent->isVisible()) && visible; }


        Window *getParent() const { return parent; }

        Screen *getScreen();

        virtual bool hasFocus() const { return parent->hasFocus() && *parent->children.rbegin() == this; }

        virtual bool mouseMoved(int x, int y);
        virtual void mouseMovedOutside(void);
        virtual bool mouseDragged(int x, int y, MouseButton button);
        virtual bool mouseDown(int x, int y, MouseButton button);
        virtual bool mouseUp(int x, int y, MouseButton button);

        virtual bool mouseClicked(int x, int y, MouseButton button);
        virtual bool mouseDoubleClicked(int x, int y, MouseButton button);
        virtual bool mouseDownOutside(MouseButton button);

        virtual bool keyDown(const Key &key);
        virtual bool keyUp(const Key &key);


        virtual bool raise() {
                Window *last = parent->children.back();
                for (Window *cur = parent->children.back(); cur != this; cur = parent->children.back()) {
                        parent->children.remove(cur);
                        parent->children.push_front(cur);
                }
                if (last != this) {
                        focusChanged(true);
                        last->focusChanged(false);
                }
                parent->setDirty();
                return true;
        }

        virtual void lower() {
                parent->children.remove(this);
                parent->children.push_front(this);
                if (this != parent->children.back()) {
                        parent->children.back()->focusChanged(true);
                        focusChanged(false);
                }
                parent->setDirty();
        }

        Window *getChild(int n) {
                for (std::list<Window *>::const_iterator i = children.begin(); i != children.end(); ++i) {
                        if ((n--) == 0) return *i;
                }
                return NULL;
        }

    unsigned int getChildCount(void) {
        return (unsigned int)children.size();
    }

};

/* Window wrapper to make scrollable regions */
class WindowInWindow : public Window {
protected:
    void scrollToWindow(Window *child);
public:
        WindowInWindow(Window *parent, int x, int y, int w, int h) :
                Window(parent,x,y,w,h) {}

        virtual bool mouseDragged(int x, int y, MouseButton button);
        virtual bool mouseDown(int x, int y, MouseButton button);
        virtual bool mouseUp(int x, int y, MouseButton button);

        virtual bool mouseMoved(int x, int y);

        virtual bool mouseClicked(int x, int y, MouseButton button);
        virtual bool mouseDoubleClicked(int x, int y, MouseButton button);

        virtual bool keyDown(const Key &key);

        virtual void paintAll(Drawable &d) const;

        virtual void resize(int w, int h);

    virtual void enableScrollBars(bool hs,bool vs);
    virtual void enableBorder(bool en);

    bool    hscroll_dragging = false;
    bool    vscroll_dragging = false;

    bool    dragging = false;
    int     drag_x = 0, drag_y = 0;

    int     scroll_pos_x = 0;
    int     scroll_pos_y = 0;
    int     scroll_pos_w = 0;
    int     scroll_pos_h = 0;

    bool    hscroll = false;
    bool    vscroll = false;

    int     hscroll_display_width = 16;
    int     vscroll_display_width = 16;

    bool    border = false;
};

class Screen : public Window {
protected:
        Drawable *const buffer;
    bool buffer_i_alloc;

        String clipboard;

        MouseButton button = (MouseButton)0;

        virtual void rgbToSurface(RGB color, void **pixel) = 0;

        virtual RGB surfaceToRGB(void *pixel) = 0;

        Screen(Size width, Size height);

        Screen(Drawable *d);

public:
        virtual ~Screen();

        template <typename STR> void setClipboard(const STR s) { this->setClipboard(String(s)); }

        virtual void setClipboard(const String &s) { clipboard = s; }

        virtual const String& getClipboard() { return clipboard; }

        virtual void resize(int w, int h);

        virtual void move(int x, int y);

        virtual bool hasFocus() const { return true; }


        Ticks update(void *surface, Ticks ticks = 1);

        virtual void paint(Drawable &d) const;
};

class Timer;

struct Timer_Callback {
public:

                virtual Ticks timerExpired(Ticks time) = 0;
                virtual ~Timer_Callback() {}
};

class Timer {
protected:
        static Ticks ticks;

        struct ltuint { bool operator()(Ticks i1, Ticks i2) const {
                return (i1 < i2);
        } };

        static std::multimap<Ticks,Timer_Callback*,ltuint> timers;

public:
        static void check(Ticks ticks);
        static void check_to(Ticks ticks);


        static void add(Timer_Callback *cb, const Ticks ticks) { timers.insert(std::pair<const Ticks,Timer_Callback *>(ticks+Timer::ticks,cb)); }

        static void remove(const Timer_Callback *const timer);

        static Ticks now() { return ticks; }

        static Ticks next();
};


class ScreenRGB32le : public Screen {
protected:
        virtual void rgbToSurface(RGB color, void **pixel) { RGB **p = (RGB **)pixel; **p = color; (*p)++; };

        virtual RGB surfaceToRGB(void *pixel) { return *(RGB*)pixel; };
public:
        ScreenRGB32le(Size width, Size height) : Screen(width,height) {};

        virtual void paint(Drawable &d) const;
};


#ifdef SDL_MAJOR_VERSION

class ScreenSDL : public Screen {
protected:
        virtual void rgbToSurface(RGB color, void **pixel) { (void)color; (void)pixel; };

        virtual RGB surfaceToRGB(void *pixel) { (void)pixel; return 0; };

        SDL_Surface *surface;
        Uint32 start_abs_time,current_abs_time,current_time;

        int downx, downy;

        Ticks lastclick,lastdown;

public:

        ScreenSDL(SDL_Surface *surface);
    virtual ~ScreenSDL();

        void setSurface(SDL_Surface *surface) { this->surface = surface; }

        SDL_Surface *getSurface() { return surface; }

        virtual void paint(Drawable &d) const;

        Ticks update(Ticks ticks);

        bool event(const SDL_Event *ev) { return event(*ev); }

        void watchTime();
        Uint32 getTime() { return current_time; }

        bool event(const SDL_Event& event);
};
#endif

class Font;

class Drawable {
protected:
        friend Ticks Screen::update(void *, Ticks);
        RGB *const buffer;
        const int width;
        const int height;
        const bool owner;

        RGB color;
        const Font *font;
        int lineWidth;

        const int tx;
        const int ty;
        const int cx;
        const int cy;
        const int cw;
        const int ch;
        const int fw;
        const int fh;

        int x;
        int y;

public:

        Drawable(int w, int h, RGB clear = Color::Transparent);


        Drawable(Drawable &src, RGB clear = 0);

        Drawable(Drawable &src, int x, int y, int w, int h);

        virtual ~Drawable();

        void clear(RGB clear = Color::Transparent);


        void setColor(RGB c) { color = c; };
        RGB getColor() { return color; };

        void setFont(const Font *f) { font = f; };
        const Font *getFont() { return font; };

        void setLineWidth(int w) { lineWidth = w; };
        int getLineWidth() { return lineWidth; };

        void gotoXY(int x, int y) { this->x = x; this->y = y; };
        int getX() { return x; }
        int getY() { return y; }

        int getClipX() { return cx; }
        int getClipY() { return cy; }
        int getClipWidth() { return cw; }
        int getClipHeight() { return ch; }

        void drawPixel() { if (x >= cx && x < cw && y >= cy && y < ch) buffer[x+tx+(y+ty)*width] = color; };
        void drawPixel(int x, int y) { gotoXY(x,y); drawPixel(); };

        RGB getPixel() { if (x >= cx && x < cw && y >= cy && y < ch) return buffer[x+tx+(y+ty)*width]; return Color::Transparent; };
        RGB getPixel(int x, int y) { gotoXY(x,y); return getPixel(); };

        void drawLine(int x2, int y2);
        void drawLine(int x1, int y1, int x2, int y2) { gotoXY(x1,y1); drawLine(x2,y2); };

        void drawDotLine(int x2, int y2);
        void drawDotLine(int x1, int y1, int x2, int y2) { gotoXY(x1,y1); drawDotLine(x2,y2); };


        void drawCircle(int d);

        void drawCircle(int x, int y, int d) { gotoXY(x, y); drawCircle(d); };


        void drawRect(int w, int h);

        void drawRect(int x, int y, int w, int h) { gotoXY(x, y); drawRect(w, h); };


        void drawDotRect(int w, int h);

        void drawDotRect(int x, int y, int w, int h) { gotoXY(x, y); drawDotRect(w, h); };


        void fill();

        void fill(int x, int y) { gotoXY(x,y); fill(); };


        void fillCircle(int d);

        void fillCircle(int x, int y, int d) { gotoXY(x, y); fillCircle(d); };


        void fillRect(int w, int h);

        void fillRect(int x, int y, int w, int h) { gotoXY(x, y); fillRect(w, h); };


        void drawText(const String& text, bool interpret = true, Size start = 0, Size len = (Size)-1);


        template <typename STR> void drawText(int x, int y, const STR text, bool interpret, Size start, Size len = (Size)-1) { gotoXY(x,y); drawText(String(text), interpret, start, len); }

        void drawText(const Char c, bool interpret = false);

        void drawText(int x, int y, const Char c, bool interpret = false) { gotoXY(x,y); drawText(c, interpret); }


        void drawDrawable(Drawable &d, unsigned char alpha = 1);

        void drawDrawable(int x, int y, Drawable &d, unsigned char alpha = 1) { gotoXY(x,y); drawDrawable(d, alpha); }

};

class Font {
protected:
        friend void Drawable::drawText(const Char c, bool interpret);
        friend void Drawable::drawText(const String& s, bool interpret, Size start, Size len);

        struct ltstr { bool operator()(const char* s1, const char* s2) const {
                return strcmp(s1, s2) < 0;
        } };
        static std::map<const char *,Font *,ltstr> registry;

        Font() {};


        virtual void drawChar(Drawable *d, const Char c) const = 0;


        virtual void drawString(Drawable *d, const String &s, Size start, Size len) const {
                if (len > s.size()-start) len = (Size)(s.size()-start);
                len += start;
                while (start < len) drawChar(d,s[start++]);
        }

public:

        static const Font *getFont(const char *name) {
                std::map<const char *,Font *,ltstr>::iterator i = registry.find(name);
                if (i == registry.end()) return(strcmp(name,"default")?getFont("default"):NULL);
                return (*i).second;
        }

        static void registry_freeall() {
                std::map<const char *,Font *,ltstr>::iterator it;

                while ((it=registry.begin()) != registry.end()) {
                        delete it->second;
                        it->second = NULL;
                        registry.erase(it);
                }
        }


        static void addFont(const char *name, Font *font) {
                std::map<const char *,Font *,ltstr>::iterator i = registry.find(name);
                if (i != registry.end()) delete (*i).second;
                registry[name] = font;
        }

        virtual ~Font() {};

        virtual int getHeight() const = 0;

        virtual int getAscent() const = 0;

        template <typename STR> int getWidth(const STR s, Size start = 0, Size len = (Size)-1) const {
                return this->getWidth(String(s), start, len);
        }

        virtual int getWidth(Char c = 'M') const = 0;


        virtual int getWidth(const String &s, Size start = 0, Size len = (Size)-1) const {
                int width = 0;
                if ((size_t)start+len > s.size()) len = (Size)(s.size()-start);
                while (len--) width += getWidth(s[start++]);
                return width;
        }

        enum SpecialChar { CR = '\r', LF = '\n', BS = '\b', Tab = '\t', Space = ' ', ESC = 27 };

        virtual SpecialChar toSpecial(Char c) const { return (SpecialChar)(c<255?c:255); }

        virtual Char fromSpecial(SpecialChar c) const { return c; }
};

class BitmapFont : public Font {
protected:
        const unsigned char *const bitmap;

        const int width;

        const int height;

        const int ascent;

        const int *const widths;


        const int *const ascents;

        const bool background_set;

        const int col_step;

        const int row_step;


        const int character_step;

        const unsigned char *const*const char_position;


        const SpecialChar *const special;

        const bool owner;

        const Char last;


        virtual void drawChar(Drawable *d, const Char c) const;

public:

        BitmapFont(const unsigned char *data, int height, int ascent, bool owner = false,
                int width = 8, bool background_set = false,
                int col_step = -1, int row_step = 8, int character_step = 0, Char last = 256,
                const int *widths = NULL, const int *ascents = NULL,
                const unsigned char *const* char_position = NULL,
                const SpecialChar *special = NULL);

        virtual ~BitmapFont();

        virtual int getHeight() const { return height; };

        virtual int getAscent() const { return ascent; };

        virtual int getWidth(Char c = 'M') const { return (widths != NULL?widths[c]:width); };

        virtual SpecialChar toSpecial(Char c) const { return (special != NULL?special[c]:Font::toSpecial(c)); }

        virtual Char fromSpecial(SpecialChar c) const { if (special == NULL) return Font::fromSpecial(c); Char i = 0; while(special[i] != c) i++; return i; }

};

class ActionEventSource;
struct ActionEventSource_Callback {
public:

                virtual void actionExecuted(ActionEventSource *source, const String &arg) = 0;
                virtual ~ActionEventSource_Callback() {}
};


class ActionEventSource {
protected:
        std::list<ActionEventSource_Callback *> actionHandlers;


        String name;

public:
        template <typename STR> ActionEventSource(const STR name) : name(String(name)) { }

        virtual ~ActionEventSource() {}

        void addActionHandler(ActionEventSource_Callback *handler) { actionHandlers.push_back(handler); }

        void removeActionHandler(ActionEventSource_Callback *handler) { actionHandlers.remove(handler); }

        template <typename STR> void setName(const STR name) { this->name = String(name); }

        const String &getName() const { return name; }

        void executeAction(const String &arg) {
                std::list<ActionEventSource_Callback*>::iterator i = actionHandlers.begin();
                bool end = (i == actionHandlers.end());
                while (!end) {
                        ActionEventSource_Callback *c = *i;
                        ++i;
                        end = (i == actionHandlers.end());
                        c->actionExecuted(this,arg);
                }
        }

        void executeAction() { executeAction(name); }
};

class BorderedWindow : public Window {
protected:
        int border_left, border_top, border_right, border_bottom;

        BorderedWindow(Window *parent, int x, int y, int w, int h, int bl, int bt, int br, int bb) :
                Window(parent,x,y,w,h), border_left(bl), border_top(bt), border_right(br), border_bottom(bb) {}

public:
        virtual void paintAll(Drawable &d) const;
        virtual bool mouseMoved(int x, int y);
        virtual bool mouseDown(int x, int y, MouseButton button);
        virtual bool mouseDragged(int x, int y, MouseButton button);
        virtual bool mouseUp(int x, int y, MouseButton button);
        virtual int getScreenX() const { return Window::getScreenX()+border_left; }
        virtual int getScreenY() const { return Window::getScreenY()+border_top; }
};


class Label : public Window {
        const Font *font;

        RGB color;

        String text;

        bool interpret;

public:

    bool allow_focus = false;


        template <typename STR> Label(Window *parent, int x, int y, const STR text, int width = 0, const Font *font = Font::getFont("default"), RGB color = Color::Text) :
                Window(parent, x, y, (width?width:1), 1), font(font), color(color), text(text), interpret(width != 0)
        { Label::resize(); tabbable = false; }

        template <typename STR> void setText(const STR text) { this->text = text; resize(); }
        const String& getText() { return text; }

        void setFont(const Font *font) { this->font = font; resize(); }
        const Font *getFont() { return font; }

        void setColor(const RGB color) { this->color = color; resize(); }
        RGB getColor() { return color; }

        virtual void resize(int w = -1, int h = -1) {
        (void)h;//UNUSED
                if (w == -1) w = (interpret?getWidth():0);
                else interpret = (w != 0);
                Drawable d((w?w:1), 1);
                d.setFont(font);
                d.drawText(0, font->getAscent(), text, interpret, 0);
                if (interpret) Window::resize(w, d.getY()-font->getAscent()+font->getHeight());
                else Window::resize(d.getX(), font->getHeight());
        }

        virtual bool hasFocus() const { return allow_focus && Window::hasFocus(); }

        virtual void paint(Drawable &d) const { d.setColor(color); d.drawText(0, font->getAscent(), text, interpret, 0); if (hasFocus()) d.drawDotRect(0,0,width-1,height-1); }

        virtual bool raise() { return false; }
};



class Input : public Window, public Timer_Callback, public ActionEventSource {
protected:
        String text;

        Size pos;

        Size lastpos;

        int posx, posy;

        Size start_sel, end_sel;

        bool blink;

        bool insert;

        bool multi;

        int offset;

    bool enable_tab_input;

        void checkOffset() {
                if (lastpos == pos) return;
                const Font *f = Font::getFont("input");
                if (multi) {
                        Drawable d(width-6,1);
                        d.setFont(f);
                        d.drawText(0, 0, text, multi, 0, pos);
                        posy = d.getY();
                        posx = d.getX();
                        if (posy-offset > height-8-f->getHeight()) offset = posy-height+8+f->getHeight();
                        if (posy-offset < 0) offset = posy;
                } else {
                        posy = 0;
                        posx = f->getWidth(text,0,pos);
                        if (f->getWidth(text,0,pos+1)-offset > width-10) offset = f->getWidth(text,0,pos+1)-width+10;
                        if (f->getWidth(text,0,(pos>0?pos-1:0))-offset < 0) offset = f->getWidth(text,0,(pos>0?pos-1:0));
                }
                lastpos = pos;
                setDirty();
        }

public:
        Input(Window *parent, int x, int y, int w, int h = 0) :
                Window(parent,x,y,w,(h?h:Font::getFont("input")->getHeight()+10)), ActionEventSource("GUI::Input"),
                text(""), pos(0), lastpos(0), posx(0), posy(0), start_sel(0), end_sel(0), blink(true), insert(true), multi(h != 0), offset(0), enable_tab_input(false)
        { Timer::add(this,30); }

        ~Input() {
                Timer::remove(this);
        }

        virtual void paint(Drawable &d) const;

        void clearSelection() {
                text.erase(text.begin()+int(pos = imin(start_sel,end_sel)),text.begin()+int(imax(start_sel,end_sel)));
                start_sel = end_sel = pos;
        }

        void copySelection() {
                setClipboard(String(text.begin()+int(imin(start_sel,end_sel)),text.begin()+int(imax(start_sel,end_sel))));
        }

        void cutSelection() {
                setClipboard(String(text.begin()+int(imin(start_sel,end_sel)),text.begin()+int(imax(start_sel,end_sel))));
                clearSelection();
        }

        void pasteSelection() {
                String c = getClipboard();
                clearSelection();
                text.insert(text.begin()+int(pos),c.begin(),c.end());
                start_sel = end_sel = pos += (Size)c.size();
        }

        Size findPos(int x, int y);

        template <typename STR> void setText(const STR text) { this->text = text; setDirty(); }
        const String& getText() { return text; };

        virtual bool keyDown(const Key &key);

        virtual bool mouseDown(int x, int y, MouseButton button);

        virtual bool mouseDragged(int x, int y, MouseButton button);

        virtual Ticks timerExpired(Ticks time)
        { (void)time; blink = !blink; setDirty(); return 30; }

        virtual void posToEnd(void);
};

class ToplevelWindow;
struct ToplevelWindow_Callback {
public:

                virtual bool windowClosing(ToplevelWindow *win) = 0;


                virtual void windowClosed(ToplevelWindow *win) = 0;
                virtual ~ToplevelWindow_Callback() {}
};

class ToplevelWindow : public BorderedWindow, public ActionEventSource_Callback {
protected:
        String title;

        int dragx, dragy;

        std::list<ToplevelWindow_Callback *> closehandlers;

        Menu *systemMenu;

public:
        template <typename STR> ToplevelWindow(Screen *parent, int x, int y, int w, int h, const STR title);

        ~ToplevelWindow() {
                std::list<ToplevelWindow_Callback*>::iterator i = closehandlers.begin();
                bool end = (i == closehandlers.end());
                while (!end) {
                        ToplevelWindow_Callback *c = *i;
                        ++i;
                        end = (i == closehandlers.end());
                        c->windowClosed(this);
                }
        }

        virtual void actionExecuted(ActionEventSource *src, const String &item) {
        (void)src;
                if (item == String("Close")) close();
        }

        void addCloseHandler(ToplevelWindow_Callback *handler) { closehandlers.push_back(handler); }

        void removeCloseHandler(ToplevelWindow_Callback *handler) { closehandlers.remove(handler); }

        virtual void paint(Drawable &d) const;
        virtual bool mouseDown(int x, int y, MouseButton button);
        virtual bool mouseDoubleClicked(int x, int y, MouseButton button);
        virtual bool mouseUp(int x, int y, MouseButton button) {
                if (button == Left && dragx >= 0 && dragy >= 0) {
                        dragx = dragy = -1;
                        return true;
                }
                BorderedWindow::mouseUp(x,y,button);
                return true;
        }
        virtual bool mouseDragged(int x, int y, MouseButton button) {
                if (button == Left && dragx >= 0 && dragy >= 0) {
                        move(x-dragx+this->x,y-dragy+this->y);
                        return true;
                }
                BorderedWindow::mouseDragged(x,y,button);
                return true;
        }
        virtual bool mouseMoved(int x, int y) {
                BorderedWindow::mouseMoved(x,y);
                return true;
        }

        virtual bool raise() {
                Window *last = parent->children.back();
                parent->children.remove(this);
                parent->children.push_back(this);
                if (last != this) {
                        focusChanged(true);
                        last->focusChanged(false);
                }
                return true;
        }

        template <typename STR> void setTitle(const STR title) { this->title = title; setDirty(); }
        const String& getTitle() { return title; }

        void close() {
                bool doit = true;
                std::list<ToplevelWindow_Callback*>::iterator i = closehandlers.begin();
                bool end = (i == closehandlers.end());
                while (!end) {
                        ToplevelWindow_Callback *c = *i;
                        ++i;
                        end = (i == closehandlers.end());
                        doit = doit && c->windowClosing(this);
                }
                if (doit) delete this;
        }
};


class TransientWindow : public Window, Window_Callback, ToplevelWindow_Callback {
protected:
        Window *realparent;

        int relx, rely;

public:
        virtual void focusChanged(bool gained) {
                Window::focusChanged(gained);
                if (isVisible() && !gained) {
                        if (realparent->hasFocus()) raise();
                        else setVisible(false);
                }
        }

        void windowClosed(ToplevelWindow *win) {
        (void)win;
                delete this;
        }

        bool windowClosing(ToplevelWindow *win) { (void)win; return true; }


        TransientWindow(Window *parent, int x, int y, int w, int h) :
                Window(parent->getScreen(),x+parent->getScreenX(),y+parent->getScreenY(),w,h),
                realparent(parent), relx(x), rely(y) {
                Window *p = realparent, *last = NULL, *last2 = NULL;
                while (p != NULL) {
                        p->addWindowHandler(this);
                        last2 = last;
                        last = p;
                        p = p->getParent();
                }
        transient = true;
                dynamic_cast<ToplevelWindow *>(last2)->addCloseHandler(this);
        }

        ~TransientWindow() {
                Window *p = realparent, *last = NULL, *last2 = NULL;
                while (p != NULL) {
                        p->removeWindowHandler(this);
                        last2 = last;
                        last = p;
                        p = p->getParent();
                }
                dynamic_cast<ToplevelWindow *>(last2)->removeCloseHandler(this);
         }

        virtual void move(int x, int y) { relx = x; rely = y;
                Window::move(x+realparent->getScreenX(),y+realparent->getScreenY()); }
        virtual int getX() const { return x-realparent->getScreenX(); }
        virtual int getY() const { return y-realparent->getScreenY(); }
        virtual void setVisible(bool v) { if (v) raise(); Window::setVisible(v); }
        virtual void windowMoved(Window *src, int x, int y) { (void)src; (void)x; (void)y; move(relx,rely); }
    virtual bool mouseDownOutside(MouseButton button) {
        (void)button;

        if (visible) {
            setVisible(false);
            return true;
        }

        return false;
    }

        virtual bool raise() {
                Window *last = parent->children.back();
                parent->children.remove(this);
                parent->children.push_back(this);
                if (last != this) {
                        focusChanged(true);
                        last->focusChanged(false);
                }
                return true;
        }

};


class Menu : public TransientWindow, public ActionEventSource {
protected:
        std::vector<String> items;

    unsigned int rows = 0;
    unsigned int columns = 0;
    std::vector<unsigned int> colx;


        int selected;

        bool firstMouseUp;

        Window *mouseTakenFrom;


        virtual void selectItem(int x, int y) {
        unsigned int coli = 0;
        int xmin,xmax,ypos = 2;

                selected = -1;

        xmin = 0;
        xmax = width;
        if (coli < colx.size()) {
            xmin = colx[coli++];
            if (coli < colx.size())
                xmax = colx[coli];
        }

        // mouse input should select nothing if outside the bounds of this menu
        if (x < 3 || x >= (width-3) || y < 2 || y >= (height-2)) return;
        selected = 0;

                const int fheight = Font::getFont("menu")->getHeight()+2;
                std::vector<String>::iterator i;
                for (i = items.begin(); i != items.end(); ++i) {
            if ((*i).size() > 0) {
                if (*i == "|") {
                    ypos = 2;
                    xmin = xmax = width;
                    if (coli < colx.size()) {
                        xmin = colx[coli++];
                        if (coli < colx.size())
                            xmax = colx[coli];
                    }
                }
                else {
                    if (x >= xmin && x < xmax) {
                        if (y >= ypos && y < (ypos+fheight))
                            break;
                    }

                    ypos += fheight;
                }
            }
            else {
                if (x >= xmin && x < xmax) {
                    if (y >= ypos && y < (ypos+12))
                        break;
                }

                ypos += 12;
            }

            selected++;
                }

                if (selected >= 0 && items[(unsigned int)selected].size() == 0) selected = -1;
        }

        virtual Size getPreferredWidth() {
                Size width = 0,px = 0;
                const Font *f = Font::getFont("menu");
                std::vector<String>::iterator i;
        columns = 1;
        colx.clear();
        colx.push_back(3+width);
        for (i = items.begin(); i != items.end() && y > 0; ++i) {
            if (*i == "|") {
                colx.push_back(3+width);
                columns++;
                px = width;
            }
            else {
                Size newwidth = (unsigned int)f->getWidth(*i) + px + 33;
                if (newwidth > width) width = newwidth;
            }
                }
                return width+6;
        }

        virtual Size getPreferredHeight() {
                Size height = 0,py = 0,row = 0;
                const Size h = (unsigned int)Font::getFont("menu")->getHeight()+2u;
                std::vector<String>::iterator i;
        rows = 0;
                for (i = items.begin(); i != items.end() && y > 0; ++i) {
            if (*i == "|") {
                py = 0;
                row = 0;
            }
            else {
                row++;
                if (rows < row) rows = row;
                py += ((*i).size() > 0?h:12);
                if (height < py) height = py;
            }
                }
                return height+6;
        }

public:

        template <typename STR> Menu(Window *parent, int x, int y, const STR name) :
                TransientWindow(parent,x,y,4,4), ActionEventSource(name), selected(-1)
                { Menu::setVisible(false); tabbable = false; }

        ~Menu() {
                Menu::setVisible(false);
        }

        virtual void paint(Drawable &d) const;

        virtual bool mouseMoved(int x, int y)  {
        if (visible) {
            firstMouseUp = false;
                selectItem(x,y);
                return true;
        }

        return false;
        }

    void mouseMovedOutside(void) {
        if (visible && selected >= 0) {
            firstMouseUp = false;
            selected = -1;
            setDirty();
        }
    }

        virtual bool mouseDragged(int x, int y, MouseButton button)  {
        (void)button;//UNUSED   

        if (visible) {
            if (x >= 0 && x < width && y >= 0 && y < height)
                firstMouseUp = false;

            selectItem(x,y);
            return true;
        }

        return false;
        }

        virtual bool mouseDown(int x, int y, MouseButton button)  {
        (void)button;//UNUSED
        (void)x;//UNUSED
        (void)y;//UNUSED

        if (visible)
            return true;

        return false;
    }

        virtual bool mouseDownOutside(MouseButton button) {
        (void)button;//UNUSED

        if (visible) {
            setVisible(false);
            selected = -1;
            return true;
        }

        return false;
    }

        virtual bool mouseUp(int x, int y, MouseButton button)  {
        (void)button;//UNUSED

        if (visible) {
            selectItem(x,y);
            if (firstMouseUp) firstMouseUp = false;
            else setVisible(false);
            execute();
            return true;
        }

        return false;
    }

        virtual bool keyDown(const Key &key) {
        if (visible) {
            if (key.special == Key::Up) {
                if (selected == 0)
                    selected = (int)items.size() - 1;
                else
                    selected--;
            }
            else if (key.special == Key::Down) {
                if ((size_t)(++selected) == items.size())
                    selected = 0;
            }
            else if (key.special == Key::Enter) { execute(); return true; }
            else if (key.special == Key::Escape) { setVisible(false); selected = -1; return true; }
            else return true;
            if (items[(unsigned int)selected].size() == 0 && items.size() > 1) return keyDown(key);
            if (selected < 0) selected = (int)(items.size()-1);
            if (selected >= (int)items.size()) selected = 0;
            return true;
        }

        return false;
        }


        template <typename T> void addItem(const T item) {
                items.push_back(String(item));
                resize((int)getPreferredWidth(),(int)getPreferredHeight());
        }

        template <typename T> void removeItem(const T item) {
                const String s(item);
                std::vector<String>::iterator i = items.begin();
                while (i != items.end() && s != (*i)) ++i;
                if (i != items.end()) items.erase(i);
                resize(getPreferredWidth(),getPreferredHeight());
        }

        virtual void setVisible(bool v) {
        if (!visible && v)
            firstMouseUp = true;

        TransientWindow::setVisible(v);
                if (v) {
                        parent->mouseChild = this;
                        raise();
                }

        // NTS: Do not set selected = -1 here on hide, other code in this C++
        //      class relies on calling setVisible() then acting on selection.
        //      Unless of course you want to hunt down random and sporadic
        //      segfaults. --J.C.
        }

        void execute() {
                if (selected >= 0) {
                        setVisible(false);

            // FIXME: Some action callbacks including the "Close" command in
            //        the system menu will delete this window object before
            //        returning to this level in the call stack. Therefore,
            //        copy selection index and clear it BEFORE calling the
            //        callbacks.
            unsigned int sel = (unsigned int)selected;
            selected = -1;

                        executeAction(items[sel]);

            // WARNING: Do not access C++ class methods or variables here,
            //          the "Close" callback may have deleted this window
            //          out from under us! It may happen to work but
            //          understand it becomes a use-after-free bug!
                }
        }
};


class Button : public BorderedWindow, public ActionEventSource {
protected:
        bool pressed;

public:
        Button(Window *parent, int x, int y, int w, int h) : BorderedWindow(parent,x,y,w,h,6,5,6,5), ActionEventSource("GUI::Button"), pressed(0) {}


        template <typename T> Button(Window *parent, int x, int y, const T text, int w = -1, int h = -1);

        virtual void paint(Drawable &d) const;

        virtual bool mouseDown(int x, int y, MouseButton button) {
        (void)button;//UNUSED
        (void)x;//UNUSED
        (void)y;//UNUSED
        
                if (button == Left) {
                        border_left = 7; border_right = 5; border_top = 7; border_bottom = 3;
                        pressed = true;
                }
                return true;
        }

        virtual bool mouseUp(int x, int y, MouseButton button)  {
        (void)button;//UNUSED
        (void)x;//UNUSED
        (void)y;//UNUSED
        
                if (button == Left) {
                        border_left = 6; border_right = 6; border_top = 5; border_bottom = 5;
                        pressed = false;
                }
                return true;
        }

        virtual bool mouseClicked(int x, int y, MouseButton button) {
        (void)button;//UNUSED
        (void)x;//UNUSED
        (void)y;//UNUSED
        
                if (button == Left) {
                        executeAction();
                        return true;
                }
                return false;
        }

        virtual bool keyDown(const Key &key);

        virtual bool keyUp(const Key &key);

};


class Menubar : public Window, public ActionEventSource, ActionEventSource_Callback {
protected:
        int selected;

        int lastx;

        std::vector<Menu*> menus;

public:

        Menubar(Window *parent, int x, int y, int w) : Window(parent,x,y,w,Font::getFont("menu")->getHeight()+5), ActionEventSource("GUI::Menubar"), selected(-1), lastx(0) { tabbable = false; }

        template <typename STR> void addMenu(const STR name) {
                const String n(name);
                menus.push_back(new Menu(this,lastx,height-2,n));
                menus.back()->addActionHandler(this);
                lastx += Font::getFont("menu")->getWidth(n)+14;
        }

        template <typename STR> void addItem(int index, const STR name) { menus[(unsigned int)index]->addItem(name); }

        template <typename STR> void removeItem(int index, const STR name) { menus[(unsigned int)index]->removeItem(name); }

        virtual void paint(Drawable &d) const;

        virtual bool mouseDown(int x, int y, MouseButton button) {
        (void)button;//UNUSED
        (void)y;//UNUSED
                int oldselected = selected;
                if (selected >= 0 && !menus[(unsigned int)selected]->isVisible()) oldselected = -1;
                if (selected >= 0) menus[(unsigned int)selected]->setVisible(false);
                if (x < 0 || x >= lastx) return true;
                for (selected = (int)(menus.size()-1); menus[(unsigned int)selected]->getX() > x; selected--) {};
                if (oldselected == selected) selected = -1;
                else menus[(unsigned int)selected]->setVisible(true);
                return true;
        }

        virtual bool keyDown(const Key &key) {
        if (key.special == Key::Tab)
            return false;

        return true;
    }

    virtual bool keyUp(const Key &key) {
        if (key.special == Key::Tab)
            return false;

        return true;
    }

        virtual void actionExecuted(ActionEventSource *src, const String &arg) {
                std::list<ActionEventSource_Callback*>::iterator i = actionHandlers.begin();
                bool end = (i == actionHandlers.end());
                while (!end) {
                        ActionEventSource_Callback *c = *i;
                        ++i;
                        end = (i == actionHandlers.end());
                        c->actionExecuted(src,arg);
                }
        }
};


class Checkbox : public BorderedWindow, public ActionEventSource {
protected:
        bool checked;

public:
        Checkbox(Window *parent, int x, int y, int w, int h) : BorderedWindow(parent,x,y,w,h,16,0,0,0), ActionEventSource("GUI::Checkbox"), checked(0) {}


        template <typename T> Checkbox(Window *parent, int x, int y, const T text, int w = -1, int h = -1);

        virtual void paint(Drawable &d) const;

        virtual void setChecked(bool checked) { this->checked = checked; }

        virtual bool isChecked() { return checked; }

        virtual bool mouseDown(int x, int y, MouseButton button) {
        (void)button;//UNUSED
        (void)x;//UNUSED
        (void)y;//UNUSED        
                checked = !checked;
                return true;
        }

        virtual bool mouseUp(int x, int y, MouseButton button)  {
        (void)button;//UNUSED
        (void)x;//UNUSED
        (void)y;//UNUSED        
                execute();
                return true;
        }

        virtual bool keyDown(const Key &key);

        virtual bool keyUp(const Key &key);

        virtual void execute() {
                String arg(name);
                if (!checked) arg.insert(arg.begin(),'!');
                executeAction(arg);
        }
};

class Frame;


class Radiobox : public BorderedWindow, public ActionEventSource {
protected:
        bool checked;

public:
        Radiobox(Frame *parent, int x, int y, int w, int h);


        template <typename T> Radiobox(Frame *parent, int x, int y, const T text, int w = -1, int h = -1);

        virtual void paint(Drawable &d) const;

        virtual void setChecked(bool checked) { this->checked = checked; }

        virtual bool isChecked() { return checked; }

        virtual bool mouseDown(int x, int y, MouseButton button) {
        (void)button;//UNUSED
        (void)x;//UNUSED
        (void)y;//UNUSED
        checked = true;
                return true;
        }

        virtual bool mouseUp(int x, int y, MouseButton button)  {
        (void)button;//UNUSED
        (void)x;//UNUSED
        (void)y;//UNUSED
                executeAction();
                return true;
        }

        virtual bool keyDown(const Key &key);

        virtual bool keyUp(const Key &key);
};


class Frame : public BorderedWindow, public ActionEventSource, protected ActionEventSource_Callback {
protected:
        friend class Radiobox;

        int selected;

        String label;

        virtual void actionExecuted(ActionEventSource *src, const String &arg) {
        // HACK: Attempting to cast a String to void causes "forming reference to void" errors when building with GCC 4.7
        (void)arg.size();//UNUSED
                for (std::list<Window *>::iterator i = children.begin(); i != children.end(); ++i) {
                        Radiobox *r = dynamic_cast<Radiobox*>(*i);
                        if (r != NULL && src != dynamic_cast<ActionEventSource*>(r)) r->setChecked(false);
                }
                executeAction(src->getName());
        }

public:
        Frame(Window *parent, int x, int y, int w, int h) : BorderedWindow(parent,x,y,w,h,5,5,5,5), ActionEventSource("GUI::Frame"), selected(0) {}

        template <typename T> Frame(Window *parent, int x, int y, int w, int h, const T text) :
                BorderedWindow(parent,x,y,w,h,5,Font::getFont("default")->getHeight()+2,5,5),
                ActionEventSource(text), selected(0), label(text) { }

        virtual void paint(Drawable &d) const;

};

class MessageBox2 : public GUI::ToplevelWindow {
protected:
        Label *message;
        Button *close;
    WindowInWindow *wiw;
public:
        template <typename STR> MessageBox2(Screen *parent, int x, int y, int width, const STR title, const STR text) :
                ToplevelWindow(parent, x, y, width, 1, title) {
        wiw = new WindowInWindow(this, 5, 5, width-border_left-border_right-10, 70);
                message = new Label(wiw, 0, 0, text, width-border_left-border_right-10);
                close = new GUI::Button(this, (width-border_left-border_right-70)/2, 10, "Close", 70);
                close->addActionHandler(this);
                setText(text);

                close->raise(); /* make sure keyboard focus is on the close button */
                this->raise(); /* make sure THIS WINDOW has the keyboard focus */
        }

        template <typename STR> void setText(const STR text) {
        int sfh;
        int msgw;
        bool scroll = true;

        msgw = width-border_left-border_right-10;
        message->resize(msgw, message->getHeight());
                message->setText(text);

        {
            Screen *s = getScreen();
            sfh = s->getHeight() - 70 - border_top - border_bottom;
            if (sfh > (15+message->getHeight())) {
                sfh = (15+message->getHeight());
                scroll = false;
            }
        }

        wiw->enableBorder(scroll);
        wiw->enableScrollBars(false/*h*/,scroll/*v*/);
        if (scroll) {
            msgw -= wiw->vscroll_display_width;
            msgw -= 2/*border*/;
            message->resize(msgw, message->getHeight());
        }

                close->move((width-border_left-border_right-70)/2, sfh);
        wiw->resize(width-border_left-border_right-10, sfh-10);
                resize(width, sfh+close->getHeight()+border_bottom+border_top+5);
        }

        virtual bool keyDown(const GUI::Key &key) {
        if (GUI::ToplevelWindow::keyDown(key)) return true;
        return false;
    }

        virtual bool keyUp(const GUI::Key &key) {
        if (GUI::ToplevelWindow::keyUp(key)) return true;

        if (key.special == GUI::Key::Escape) {
            close->executeAction();
            return true;
        }

        return false;
    }
};

extern int titlebar_y_start;
extern int titlebar_y_stop;

extern int titlebox_y_start;
extern int titlebox_y_height;

template <typename STR> ToplevelWindow::ToplevelWindow(Screen *parent, int x, int y, int w, int h, const STR title) :
        BorderedWindow(parent, x, y, w, h, 6, titlebar_y_stop, 6, 3), title(title),
        dragx(-1), dragy(-1), closehandlers(), systemMenu(new Menu(this,-1,-2,"System Menu")) {
/* If these commands don't do anything, then why have them there?? --J.C. */
#if 0 /* TODO: Allow selective enabling these if the Window object wants us to */
        systemMenu->addItem("Move");
        systemMenu->addItem("Resize");
        systemMenu->addItem("");
        systemMenu->addItem("Minimize");
        systemMenu->addItem("Maximize");
        systemMenu->addItem("Restore");
        systemMenu->addItem("");
#endif
        systemMenu->addItem("Close");
        systemMenu->addActionHandler(this);
    toplevel = true;
}

template <typename STR> Button::Button(Window *parent, int x, int y, const STR text, int w, int h) :
        BorderedWindow(parent,x,y,w,h,6,5,6,5), ActionEventSource(text), pressed(0)
{

        Label *l = new Label(this,0,0,text);
    l->allow_focus = true;
        if (width < 0) resize(l->getWidth()+border_left+border_right+10,height);
        if (height < 0) resize(width,l->getHeight()+border_top+border_bottom+6);
        l->move((width-border_left-border_right-l->getWidth())/2,
                (height-border_top-border_bottom-l->getHeight())/2);
}

template <typename STR> Checkbox::Checkbox(Window *parent, int x, int y, const STR text, int w, int h) :
        BorderedWindow(parent,x,y,w,h,16,0,0,0), ActionEventSource(text), checked(0)
{
        Label *l = new Label(this,0,0,text);
        if (width < 0) resize(l->getWidth()+border_left+border_right+4,height);
        if (height < 0) resize(width,l->getHeight()+border_top+border_bottom+4);
        l->move((width-border_left-border_right-l->getWidth())/2,
                (height-border_top-border_bottom-l->getHeight())/2);
}

template <typename STR> Radiobox::Radiobox(Frame *parent, int x, int y, const STR text, int w, int h) :
        BorderedWindow(parent,x,y,w,h,16,0,0,0), ActionEventSource(text), checked(0)
{
        Label *l = new Label(this,0,0,text);
        if (width < 0) resize(l->getWidth()+border_left+border_right+4,height);
        if (height < 0) resize(width,l->getHeight()+border_top+border_bottom+4);
        l->move((width-border_left-border_right-l->getWidth())/2,
                (height-border_top-border_bottom-l->getHeight())/2);
        addActionHandler(parent);
}

}

#endif