---

XGraphicsSystem.cc

Go to the documentation of this file.

/*
    File:           XGraphicsSystem.cc

    Function:       See header file

    Author(s):      Andrew Willmott

    Copyright:      (c) 1995-2000, Andrew Willmott

    Notes:          
*/

#include "gcl/XGraphicsSystem.h"

#include <sys/time.h>
#include <sys/types.h>

#include <stdlib.h>
#include <unistd.h>
#include <iostream.h>
#include <errno.h>

#ifdef GCL_XSHM
#define Bool int
#include <sys/ipc.h>
#include <sys/shm.h>
#include <X11/extensions/XShm.h>
#undef Bool
#endif

#define DBG_COUT if (0) cerr

/*
    Design notes:

    -   XGraphicsSystem implements raw, standalone X windows.  We must
        make allowance here for our windows being used in other higher
        level toolkits, though -- e.g., the forms package.  This is the
        rationale for CreateWindow() etc. not being a method of the
        X*Pane classes.

    -   Currently only supports images in 16/24-bit truecolor.  This is
        because X has no high-level API for colour management, no support
        for converting between bit depths, no support for almost
        anything except network sockets and useless error messages.

        Just how bad is the wretched X11? Consider that there's 307
        lines of code in this file to support what can be done with a
        one-line "CopyBits" call in any other graphical OS. And parts of
        that code have to handle completely undocumented features. Now,
        consider that that code is replicated in almost any X11 app that
        does image manipulation.

        ACM TOG '98 has an article on how to do sane colour management
        with X. The scheme it proposes is remarkably similar to what the
        Mac was doing in the late 80's, but the author seems to be
        unaware of that.

        If it becomes necessary to do generic support for all different
        visual types, prob. best to require something like gtk+/imlib,
        which I believe includes the colour management routines from
        XmHTML.

 */

// --- XWindows-specific Graphics System... -----------------------------------

Bool XGraphicsSystem::finished = false;

#ifdef GCL_XSHM
static Bool gShmError = false;
static XErrorHandler gOldHandler = 0;
static Int ShmErrHandler(Display *dpy, XErrorEvent *error)
{
    gShmError = true;
    return 0;
}
#endif

XGraphicsSystem::XGraphicsSystem() : hasGC(false), sharedOn(true), 
            remoteChecked(false)
//  Initialise the system
{
    itsEventsMask = 
        StructureNotifyMask | KeyPressMask | ButtonPressMask | ExposureMask;

    display = XOpenDisplay(0);
    
    if (display == 0)
    {
        cerr << "FATAL: Can't open connection to X W**dows server." << endl;
        cerr << "(Check the DISPLAY environment variable.)" << endl;
        exit(1);
    }

#ifdef GCL_XSHM
    if (!XShmQueryExtension(display))
        sharedOn = false;
#endif

#ifdef DEBUG
    XSynchronize(display, True);
#endif  
}

XGraphicsSystem::~XGraphicsSystem()
{
}

Void XGraphicsSystem::Spin()
{
    XEvent      event;
    Int         i;
    
    // handle all outstanding events for our windows
    for (i = 0; i < paneList.NumItems(); i++)
        while (XCheckWindowEvent(display, paneList[i]->paneXID, 
                ButtonPressMask | KeyPressMask | ExposureMask, &event))
            paneList[i]->XHandleEvent(&event);
}

Bool XGraphicsSystem::RunFor(Float time)
{
    struct timeval  timeOut;
    Int             displayFD = ConnectionNumber(display);
    fd_set          readSet;

    timeOut.tv_sec = (Long) time;
    timeOut.tv_usec = (Long) ((time - timeOut.tv_sec) * 1e6);

    FD_ZERO(&readSet);
    FD_SET(displayFD, &readSet);

    select(displayFD + 1, &readSet, 0, 0, &timeOut);

    Spin();

    return(finished);
}

Void XGraphicsSystem::Run()
{
    XEvent      event;
    Int         i;

    finished = false;

    while (!finished)
    {
        XMaskEvent(display, 
                ButtonPressMask | KeyPressMask | ExposureMask, &event);

        for (i = 0; i < paneList.NumItems(); i++)
            if (paneList[i]->paneXID == event.xany.window)
            {
                paneList[i]->XHandleEvent(&event);
                break;
            }
        if (i == paneList.NumItems())
            cerr << "*** Unhandled X event for window " << event.xany.window << endl;
    }
}

Void XGraphicsSystem::SignalDone()
{
    finished = true;
}

Void XGraphicsSystem::GetMouse(XEventPane *xpane,
    Int *x, Int *y, UInt *keyState)
{
    Int     x1, x2;
    Window  d1, d2;
    
    XQueryPointer(display, xpane->paneXID, &d1, &d2, &x1, &x2, x, y, keyState);
}

static int WaitForNotify(Display *display, XEvent *event, char *arg)
{
    return((event->type == MapNotify) && (event->xmap.window == (Window) arg));
}

Void XGraphicsSystem::CreateWindow(XEventPane *xpane, StrConst title, 
        Int width, Int height)
{
    XSetWindowAttributes    windowAttributes;
    XEvent                  event;
    Colormap                colourMap;
    XVisualInfo             *theVisualInfo;
                
    xpane->width = width;
    xpane->height = height;
    xpane->xgs = this;

    theVisualInfo = xpane->GetVisualInfo();

    colourMap = XCreateColormap(display,
        RootWindow(display, theVisualInfo->screen), theVisualInfo->visual, 
        AllocNone);

    windowAttributes.colormap = colourMap;
    windowAttributes.border_pixel = 0;
    
    windowAttributes.event_mask = itsEventsMask; 

    xpane->paneXID = XCreateWindow(display,
        RootWindow(display, theVisualInfo->screen), 0, 0, width, height,
        0, theVisualInfo->depth, InputOutput, theVisualInfo->visual,
        CWBorderPixel | CWColormap | CWEventMask, &windowAttributes);

    XMapWindow(display, xpane->paneXID);

    //  Wait for notify...

    XIfEvent(display, &event, WaitForNotify, (char *) xpane->paneXID);
    
    //  Create a graphics context if it hasn't been done before...
    
    if (!hasGC) 
        theGC = XCreateGC(display, xpane->paneXID, 0, 0);

    xpane->Init();

    XStoreName(display, xpane->paneXID, title);
    XSetIconName(display, xpane->paneXID, title);
    
    paneList.Append(xpane);
}

Void XGraphicsSystem::CreateSubwindow(XEventPane *xpane, Window parent,
        Int x, Int y, Int width, Int height)
//  Create a sub-window in the parent window.
{
    XSetWindowAttributes    windowAttributes;
    XEvent                  event;
    Colormap                colourMap;
    XVisualInfo             *theVisualInfo;
    
    xpane->width = width;
    xpane->height = height;
    xpane->xgs = this;

    theVisualInfo = xpane->GetVisualInfo();
        
    colourMap = XCreateColormap(display,
        RootWindow(display, theVisualInfo->screen), theVisualInfo->visual,
        AllocNone);

    windowAttributes.colormap = colourMap;
    windowAttributes.border_pixel = 0;
    windowAttributes.event_mask = itsEventsMask;

    xpane->paneXID = XCreateWindow(display,
        parent, x, y, width, height,
        0, theVisualInfo->depth, InputOutput, theVisualInfo->visual,
        CWBorderPixel | CWColormap | CWEventMask, &windowAttributes);

    XMapWindow(display, xpane->paneXID);

    //  Wait for notify...

    XIfEvent(display, &event, WaitForNotify, (char *) xpane->paneXID);
    
    //  Create a graphics context if it hasn't been done before...
    
    if (!hasGC) 
        theGC = XCreateGC(display, xpane->paneXID, 0, 0);

    xpane->Init();
}

Void XGraphicsSystem::CreateOffscreen(XOffscreenPane *xpane, Int width, Int height)
//  Create an offscreen buffer.
{
    XVisualInfo             *theVisualInfo;
    
    xpane->xgs = this;
    xpane->width = width;
    xpane->height = height;

    theVisualInfo = xpane->GetVisualInfo();

    //  Create the Pixmap
    
    xpane->paneXID = XCreatePixmap(display, RootWindow(display,
        theVisualInfo->screen), width, height, theVisualInfo->depth);
                                
    xpane->Init();
}

Void XGraphicsSystem::DumpVisualInfo()
{
    XVisualInfo *vi;
    Int         items, i;

    vi = XGetVisualInfo(display, 0, 0, &items);
    
    for (i = 0; i < items; i++)
    {
        printf("default visual %d: class %d, depth %d, id %d\n",
               i, vi[i].c_class, vi[i].depth, vi[i].visualid);
        printf("masks: %08x %08x %08x\n",
               vi[i].red_mask,
               vi[i].green_mask,
               vi[i].blue_mask);
        printf("bits per channel: %d\n",
               vi[i].bits_per_rgb);
    }   
}


// --- SXImage class ----------------------------------------------------------


struct SXImage
// container class for XImage to deal with all the X11 shared memory stuff
{
    Void                CreateFrom(XPane *xpane, const Image &img);
    Void                Destroy();

    Void                WriteImage24(const Image &img, 
                            XVisualInfo *theVisualInfo, RGBAPixel *buffer);
    Void                WriteImage16(const Image &img, 
                            XVisualInfo *theVisualInfo, RGBAPixel *buffer);
    Void                WriteImage15(const Image &img, 
                            XVisualInfo *theVisualInfo, RGBAPixel *buffer);
    
    XImage              *ximg;
    XGraphicsSystem     *xgs;
#ifdef GCL_XSHM
    Bool                isShared;
    XShmSegmentInfo     shmInfo;
#endif
};


Void SXImage::WriteImage24(const Image &img, XVisualInfo *theVisualInfo,
                            RGBAPixel *buffer)
{
    Int             x, y;
    ULong           pixel;
    UInt32          *xbuf = ((UInt32*) ximg->data);
    Int             chn[3];

    if (theVisualInfo->red_mask == 0xFF0000
        && theVisualInfo->green_mask == 0x00FF00
        && theVisualInfo->blue_mask == 0x0000FF)
    {
        chn[0] = rgba_B; chn[1] = rgba_G; chn[2] = rgba_R;
    }
    else if (theVisualInfo->red_mask == 0x0000FF
        && theVisualInfo->green_mask == 0x00FF00
        && theVisualInfo->blue_mask == 0xFF0000)
    {
        chn[0] = rgba_R; chn[1] = rgba_G; chn[2] = rgba_B;
    }
    else
    {
        _Error(String().Printf("Can't handle pixel format: rgb = [%04x:%04x:%04x]",
            theVisualInfo->red_mask, theVisualInfo->green_mask,
            theVisualInfo->blue_mask));
    }

    for (y = img.Height() - 1; y >= 0; y--) 
    {
        img.GetRGBASpan(y, 0, img.Width(), buffer);
        for (x = 0; x < img.Width(); x++) 
        {
            pixel = 
                buffer[x].ch[chn[0]] | 
                buffer[x].ch[chn[1]] << 8 |
                buffer[x].ch[chn[2]] << 16;
            xbuf[x] = pixel;
        }
        xbuf = (UInt32*) (((Char *) xbuf) + ximg->bytes_per_line);
    }
}

Void SXImage::WriteImage16(const Image &img, XVisualInfo *theVisualInfo,
                            RGBAPixel *buffer)
{
    Int             x, y;
    ULong           pixel;
    UInt16          *xbuf = (UInt16*) ximg->data;
    Int             chn[3];

    if (theVisualInfo->red_mask == 0xF800
        && theVisualInfo->green_mask == 0x07E0
        && theVisualInfo->blue_mask == 0x001F)
    {
        chn[0] = rgba_B; chn[1] = rgba_G; chn[2] = rgba_R;
    }
    else if (theVisualInfo->red_mask == 0x001F
        && theVisualInfo->green_mask == 0x07E0
        && theVisualInfo->blue_mask == 0xF800)
    {
        chn[0] = rgba_R; chn[1] = rgba_G; chn[2] = rgba_B;
    }
    else
    {
        _Error(String().Printf("Can't handle pixel format: rgb = [%04x:%04x:%04x]",
            theVisualInfo->red_mask, theVisualInfo->green_mask,
            theVisualInfo->blue_mask));
    }

    for (y = img.Height() - 1; y >= 0; y--) 
    {
        img.GetRGBASpan(y, 0, img.Width(), buffer);
        for (x = 0; x < img.Width(); x++) 
        {
            pixel = 
                (buffer[x].ch[chn[0]] >> 3) | 
                (buffer[x].ch[chn[1]] >> 2) << 5 |
                (buffer[x].ch[chn[2]] >> 3) << 11;
            xbuf[x] = pixel;
        }
        xbuf = (UInt16*) (((Char *) xbuf) + ximg->bytes_per_line);
    }
}

Void SXImage::WriteImage15(const Image &img, XVisualInfo *theVisualInfo,
                            RGBAPixel *buffer)
{
    Int             x, y;
    ULong           pixel;
    UInt16          *xbuf = (UInt16*) ximg->data;
    Int             chn[3];

    if (theVisualInfo->red_mask == 0x7C00
        && theVisualInfo->green_mask == 0x03E0
        && theVisualInfo->blue_mask == 0x001F)
    {
        chn[0] = rgba_B; chn[1] = rgba_G; chn[2] = rgba_R;
    }
    else if (theVisualInfo->red_mask == 0x001F
        && theVisualInfo->green_mask == 0x03E0
        && theVisualInfo->blue_mask == 0x7C00)
    {
        chn[0] = rgba_R; chn[1] = rgba_G; chn[2] = rgba_B;
    }
    else
    {
        _Error(String().Printf("Can't handle pixel format: rgb = [%04x:%04x:%04x]",
            theVisualInfo->red_mask, theVisualInfo->green_mask,
            theVisualInfo->blue_mask));
    }

    for (y = img.Height() - 1; y >= 0; y--) 
    {
        img.GetRGBASpan(y, 0, img.Width(), buffer);
        for (x = 0; x < img.Width(); x++) 
        {
            pixel = 
                (buffer[x].ch[chn[0]] >> 3) | 
                (buffer[x].ch[chn[1]] >> 3) << 5 |
                (buffer[x].ch[chn[2]] >> 3) << 10;
            xbuf[x] = pixel;
        }
        xbuf = (UInt16*) (((Char *) xbuf) + ximg->bytes_per_line);
    }
}

const Int kLocBufSize = 1024;


Void SXImage::CreateFrom(XPane *xpane, const Image &img)
// Convert an Image into the X equivalent so we can blat it to an
// X pixmap/window.
// This is incredibly annoying: we have to support all the different depths
// ourselves, plus different bit arrangements (RGB, BGR, 5/5/5, 5/6/5).
// Theoretically we even have to support GBR, GRB, etc., but I've never 
// seen those in real life...
//
// Currently: supports 24 & 16/15-bit TrueColor "only".
{
    XVisualInfo     *theVisualInfo;
    RGBAPixel       bufferLocal[kLocBufSize];
    RGBAPixel       *buffer;
    
    theVisualInfo = xpane->GetVisualInfo();
    xgs = xpane->xgs;

    // XXX cache ximg here
    // need to do it on a per-visual basis: small hash table or summat.

    // first, this is X11, so we have to stuff around with shared memory

#ifdef GCL_XSHM
    isShared = false;
    
    if (xgs->sharedOn)
        do
        {
            ximg = XShmCreateImage(xgs->display,
                                   theVisualInfo->visual,
                                   theVisualInfo->depth,
                                   ZPixmap, 0, &shmInfo, img.Width(), img.Height());
            
            shmInfo.shmid = shmget(IPC_PRIVATE, ximg->bytes_per_line * ximg->height,
                                        IPC_CREAT | 0777);
            if (shmInfo.shmid < 0)
            {
                _Warning(String().Printf(
                    "(SXImage) Shared memory error %d (shmget)", errno));
                XDestroyImage(ximg);
                xgs->sharedOn = false;
                break;
            }

            shmInfo.shmaddr = (char *) shmat(shmInfo.shmid, (Void*) 0, 0);

            if (shmInfo.shmaddr == (Void*)(-1)) 
            {
                _Warning("(SXImage) Shared memory error (shmat)");
                XDestroyImage(ximg);
                if (shmctl(shmInfo.shmid, IPC_RMID, 0) < 0)
                    _Warning("(SXImage) Shared memory error (shmctl)");
                xgs->sharedOn = false;
                break;
            }
            ximg->data = shmInfo.shmaddr;

            XSync(xgs->display, False);
            // the only way to check if we're on a remote display --
            // catch the resulting X11 error!
            if (!xgs->remoteChecked)
                if (!gOldHandler)
                    gOldHandler = XSetErrorHandler(ShmErrHandler);  

            XShmAttach(xgs->display, &shmInfo);

            if (!xgs->remoteChecked)
            {
                XSync(xgs->display, False);
                if (gOldHandler)
                    XSetErrorHandler(gOldHandler);
                gOldHandler = 0;
                xgs->remoteChecked = true;
                if (gShmError)
                {
                    xgs->sharedOn = false;
                    break;
                }
            }
            isShared = true;
        }
        while (false);
    
    if (!isShared)
    {
#endif

    ximg = XCreateImage(xgs->display, theVisualInfo->visual, 
                        theVisualInfo->depth, 
                        ZPixmap, 0, 0, img.Width(), 
                        img.Height(), 32, 0);

    ximg->data = (char*) malloc(ximg->bytes_per_line * img.Height());

#ifdef GCL_XSHM
    }
#endif 

/*
 * Only some smug prick from MIT would put this in front of the XImage 
 * manipulation routines in Xutil.h:
 * 
 * These macros are used to give some sugar to the image routines so that
 * naive people are more comfortable with them.
 * 
 */

    // pitiful conversion code
    // but then we shouldn't have to be doing this in the first place

    if (img.Width() > kLocBufSize)
    {
        buffer = new RGBAPixel[img.Width()];
        if (!buffer)
        {
            _Warning("(SXImage) out of memory");
            return;
        }   
    }
    else
        buffer = bufferLocal;
        
    
    if (theVisualInfo->depth == 24)
        WriteImage24(img, theVisualInfo, buffer);
    else if (theVisualInfo->depth == 16)
        WriteImage16(img, theVisualInfo, buffer);
    else if (theVisualInfo->depth == 15)
        WriteImage15(img, theVisualInfo, buffer);
    else
        _Error(String().Printf("(SXImage) unsupported bit depth %d", theVisualInfo->depth));

    if (img.Width() > kLocBufSize)
        delete[] buffer;
}

Void SXImage::Destroy()
{
#ifdef GCL_XSHM
    if (isShared)
    {
        XSync(xgs->display, False);
        XShmDetach(xgs->display, &shmInfo);
        XDestroyImage(ximg);
        if (shmdt(shmInfo.shmaddr) < 0)
            _Warning("(SXImage) Shared memory error (shmdt)");
        if (shmctl(shmInfo.shmid, IPC_RMID, 0) < 0)
            _Warning("(SXImage) Shared memory error (shmctl)");
    }
    else
#endif
        XDestroyImage(ximg);
}


// --- XPane class ------------------------------------------------------------


XVisualInfo *XPane::sVisualInfo = 0;

XPane::XPane() : xgs(0)
{
}

Void XPane::Init()
{
}

XVisualInfo *XPane::GetVisualInfo()
{
    if (!sVisualInfo)
    {
        Int         items, i, maxDepth = 0;
        XVisualInfo *vi;

        vi = XGetVisualInfo(xgs->display, 0, 0, &items);
    
        if (vi == 0)
            _Error("Can't obtain a visual for standard XPane");

        // find max depth visual
        for (i = 0; i < items; i++)
        {
            if (vi[i].depth > maxDepth)
            {
                maxDepth = vi[i].depth;
                sVisualInfo = vi + i;
            }
        }   

    }

    return(sVisualInfo);
}

Void XPane::CopyFrom(XPane &from)
{
    XCopyArea(xgs->display, from.paneXID, paneXID,
        from.xgs->theGC, 0, 0, from.width, from.height, 0, 0);
}

Void XPane::PutImage(Image &img, Int x, Int y)
{
    SXImage sximg;

    sximg.CreateFrom(this, img);
    XPutImage(xgs->display, paneXID, xgs->theGC, sximg.ximg, 0, 0, x, y,
              img.Width(), img.Height());
    sximg.Destroy();
}

XPane::~XPane()
{
    DBG_COUT << "freeing XPane " << this << endl;
}


// --- XOffscreenPane class ---------------------------------------------------

XOffscreenPane::XOffscreenPane() : XPane()
{
}

XOffscreenPane::~XOffscreenPane()
{
    if (xgs)
    {
        DBG_COUT << "freeing pixmap " << this << endl;
        XFreePixmap(xgs->display, paneXID);
    }
}

// --- XEventPane class -------------------------------------------------------

Void XEventPane::XHandleEvent(XEvent *event)
{   
    if (event->type == Expose)
        HandleExpose();
    else if (event->type == KeyPress)   
    {
        Char    temp[8];
        Int     c;
        
        // pin-heads.
        c = XLookupString((XKeyEvent *) event, temp,
            sizeof(temp) - 1, NULL, NULL);
        temp[c] = 0;
        if (c == 1)
            HandleKey(temp[0]);
    }
    else if (event->type == ButtonPress)
    {
        XButtonEvent    *be = (XButtonEvent*) event;
        UInt            keyState = be->state;
        Int             modifiers = 0;

        if (keyState & ShiftMask)
            modifiers |= wmShift;
        if (keyState & ControlMask)
            modifiers |= wmControl;
        if (keyState & Mod1Mask)
            modifiers |= wmAlt;
        if (be->button == 1)
            modifiers |= wmButton1;
        else if (be->button == 2)
            modifiers |= wmButton2;
        else if (be->button == 3)
            modifiers |= wmButton3;
        
        TrackMouse(be->x, be->y, modifiers);
    }
}

Void XEventPane::GetMouse(Int &x, Int &y, Int &modifiers)
{
    UInt keyState;

    xgs->GetMouse(this, &x, &y, &keyState);

    modifiers = 0;
    if (keyState & ShiftMask)
        modifiers |= wmShift;
    if (keyState & ControlMask)
        modifiers |= wmControl;
    if (keyState & Mod1Mask)
        modifiers |= wmAlt;
    if (keyState & Button1Mask)
        modifiers |= wmButton1;
    if (keyState & Button2Mask)
        modifiers |= wmButton2;
    if (keyState & Button3Mask)
        modifiers |= wmButton3;
};

Void XEventPane::HandleKey(Char c)
{
    if (c == 0x1B || c == 'q')
        xgs->SignalDone();
}

Void XEventPane::HandleExpose()
{
}

Void XEventPane::TrackMouse(Int sx, Int sy, Int modifiers)
{
}

XEventPane::~XEventPane()
{   
    DBG_COUT << "deleting xeventpane " << this << endl;
    if (xgs)
    {
        Int i;
        
        for (i = 0; i < xgs->paneList.NumItems(); i++)
            if (xgs->paneList[i] == this)
                xgs->paneList.Delete(i, 1);
                
        XDestroyWindow(xgs->display, paneXID);
    }

}

Void XEventPane::Resize(Int x, Int y)
{
    XResizeWindow(xgs->display, paneXID, x, y);
}

Void XEventPane::Show()
{
    XMapWindow(xgs->display, paneXID);
}

Void XEventPane::Hide()
{
    XUnmapWindow(xgs->display, paneXID);
}

Void XEventPane::SetTitle(StrConst title)
{
    XStoreName(xgs->display, paneXID, title);
    XSetIconName(xgs->display, paneXID, title);
}

// --- XBackedPane class ------------------------------------------------------

XBackedPane::XBackedPane() : XEventPane(), backPane(0)
{
}

Void XBackedPane::Attach(XPane *pane)
{
    backPane = pane;
}

Void XBackedPane::HandleExpose()
{
    if (backPane)
        CopyFrom(*backPane);
}

---