linux/X/LgiOsClasses.h

#ifndef __OS_CLASS_H
#define __OS_CLASS_H

#include <qimage.h>
#include <qfont.h>
#include <qevent.h>
#include <qapplication.h>
#include <qpainter.h>
#include <qfont.h>
#include <qfontmetrics.h>

typedef pthread_t                   OsThread;
typedef QFont                       *OsFont;
typedef QApplication                OsApplication;
typedef QPainter                    *OsPainter;
typedef QImage                      *OsBitmap;
typedef char16                      OsChar;

#undef Bool

class GMessage : public QEvent
{
    friend class QApplication;
    XEvent Local;

    XEvent *GetLocal()
    {
        // Make sure this is set BEFORE we give it
        // to QEvent, otherwise it'll call random
        // code.
        Local.type = ClientMessage;
        return &Local;
    }

    GMessage(XEvent *e) : QEvent(e)
    {
    }

public:
    GMessage(int M = 0, int A = 0, int B = 0) : QEvent(GetLocal())
    {
        m() = M;
        a() = A;
        b() = B;
    }

    int &m() { return (int&) (GetEvent()->xclient.message_type); }
    int &a() { return (int&) (Data()[0]); }
    int &b() { return (int&) (Data()[1]); }

    long *Data()
    {
        return GetEvent()->xclient.data.l;
    }
};

#define MsgCode(Msg)                ((Msg->type() == ClientMessage) ? ((GMessage*)Msg)->m() : 0)
#define MsgA(Msg)                   ((Msg->type() == ClientMessage) ? ((GMessage*)Msg)->a() : 0)
#define MsgB(Msg)                   ((Msg->type() == ClientMessage) ? ((GMessage*)Msg)->b() : 0)

extern GMessage CreateMsg(int m, int a, int b);

template <class q>
class QView : public q
{
    friend class GView;

protected:
    GView *v;
    bool _Paint;

    void OnClick(QEvent *e, bool down, bool dbl, bool move);
    bool OnKey(QEvent *e, bool down);
    void setBackgroundMode(ViewBackground b) {}

public:
    QView(GView *view, bool p = true);
    QView(GView *view, Window Existing);
    ~QView();

    void _SetWndPtr(void *p);
    void *_GetWndPtr();
    
    // Events
    void resizeEvent(QEvent *e);
    void paintEvent(QEvent *e);
    void customEvent(QEvent *e);
    void notifyEvent(int i = 0);
    
    // Mouse events
    void mousePressEvent(QEvent *e);
    void mouseDoubleClickEvent(QEvent *e);
    void mouseReleaseEvent(QEvent *e);
    void mouseMoveEvent(QEvent *e);
    void leaveEvent(QEvent *e);
    void enterEvent(QEvent *e);
    void wheelEvent(QEvent *e);

    // Focus events
    void focusInEvent(QEvent *e);
    void focusOutEvent(QEvent *e);

    // Keyboard events
    bool keyPressEvent(QEvent *e);
    bool keyReleaseEvent(QEvent *e);
};

typedef QView<QWidget> DefaultOsView;

class QWindow : public QMainWindow
{
    GWindow *Wnd;

public:
    QWindow(GWindow *wnd);
    ~QWindow();

    void _SetWndPtr(void *p);
    void *_GetWndPtr();
    void SetModal();

    void resizeEvent(QEvent *re);
    void closeEvent(QEvent *ce);
    void paintEvent(QEvent *e);
    void customEvent(QEvent *e);
    void propertyEvent(QEvent *e);
};

class Xgc : public QObject
{
    GC Gc;
    Pixmap Pix;

public:
    Xgc(Pixmap p)
    {
        XGCValues n;
        Pix = p;
        Gc = XCreateGC( XDisplay(),
                        Pix,
                        0,
                        &n);
    }
    
    ~Xgc()
    {                   
        if (Gc)
            XFreeGC(XDisplay(), Gc);
    }
    
    operator GC()
    {
        return Gc;
    }
};

class Ximg : public QObject
{
    XImage *Img;
    int Line;
    char *Data;

public:
    Ximg(int x, int y, int depth)
    {
        Line = (x * depth + 7) / 8;
        Data = (char*)malloc(Line * y);
        Img = XCreateImage( XDisplay(),
                            DefaultVisual(XDisplay(), 0),
                            depth,
                            ZPixmap,
                            0,
                            Data,
                            x, y,
                            8,
                            Line);
    }
    
    ~Ximg()
    {
        XDestroyImage(Img);
    }

    operator XImage *()
    {
        return Img;
    }                           

    uchar *operator [](int y)
    {
        if (y >= 0 AND y < Img->height)
        {
            return (uchar*)Img->data + (y * Img->bytes_per_line);
        }
        return 0;
    }

    void Set(int x, int y, int Col)
    {
        XPutPixel(Img, x, y, Col);
    }

    int Get(int x, int y)
    {
        return XGetPixel(Img, x, y);
    }
    
    int X()
    {
        return Img->width;
    }

    int Y()
    {
        return Img->height;
    }
    
    int Depth()
    {
        return Img->depth;
    }
};

class Xpix : public QObject
{
    Drawable v;
    Pixmap Pix;

public: Xpix(Drawable draw, Ximg *Img)
    {
        v = draw;
        Pix = (Img) ? XCreatePixmap(XDisplay(),
                                    v,
                                    Img->X(),
                                    Img->Y(),
                                    Img->Depth()) : 0;
        if (Pix)
        {
            Xgc Gc(Pix);
            XPutImage(XDisplay(), Pix, Gc, *Img, 0, 0, 0, 0, Img->X(), Img->Y());
        }
    }
    
    ~Xpix()
    {
        if (Pix)
            XFreePixmap(XDisplay(), Pix);
    }
    
    operator Pixmap()
    {
        return Pix;
    }
    
    void Detach()
    {
        Pix = 0;
    }
};

#endif

---