trunk/rdesktop/xwin.c

/* -*- c-basic-offset: 8 -*-
   rdesktop: A Remote Desktop Protocol client.
   User interface services - X Window System
   Copyright (C) Matthew Chapman 1999-2005

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/

#include <X11/Xlib.h>
#include <X11/Xutil.h>
#include <unistd.h>
#include <sys/time.h>
#include <time.h>
#include <errno.h>
#include <strings.h>
#include "rdesktop.h"
#include "xproto.h"

extern int g_width;
extern int g_height;
extern int g_xpos;
extern int g_ypos;
extern int g_pos;
extern BOOL g_sendmotion;
extern BOOL g_fullscreen;
extern BOOL g_grab_keyboard;
extern BOOL g_hide_decorations;
extern char g_title[];
extern int g_server_bpp;
extern int g_win_button_size;

Display *g_display;
Time g_last_gesturetime;
static int g_x_socket;
static Screen *g_screen;
Window g_wnd;
extern uint32 g_embed_wnd;
BOOL g_enable_compose = False;
BOOL g_Unobscured;              /* used for screenblt */
static GC g_gc = NULL;
static GC g_create_bitmap_gc = NULL;
static GC g_create_glyph_gc = NULL;
static Visual *g_visual;
static int g_depth;
static int g_bpp;
static XIM g_IM;
static XIC g_IC;
static XModifierKeymap *g_mod_map;
static Cursor g_current_cursor;
static HCURSOR g_null_cursor = NULL;
static Atom g_protocol_atom, g_kill_atom;
static BOOL g_focused;
static BOOL g_mouse_in_wnd;
static BOOL g_arch_match = False;       /* set to True if RGB XServer and little endian */

/* endianness */
static BOOL g_host_be;
static BOOL g_xserver_be;
static int g_red_shift_r, g_blue_shift_r, g_green_shift_r;
static int g_red_shift_l, g_blue_shift_l, g_green_shift_l;

/* software backing store */
extern BOOL g_ownbackstore;
static Pixmap g_backstore = 0;

/* Moving in single app mode */
static BOOL g_moving_wnd;
static int g_move_x_offset = 0;
static int g_move_y_offset = 0;
static BOOL g_using_full_workarea = False;

#ifdef WITH_RDPSND
extern int g_dsp_fd;
extern BOOL g_dsp_busy;
extern BOOL g_rdpsnd;
#endif

/* MWM decorations */
#define MWM_HINTS_DECORATIONS   (1L << 1)
#define PROP_MOTIF_WM_HINTS_ELEMENTS    5
typedef struct
{
        unsigned long flags;
        unsigned long functions;
        unsigned long decorations;
        long inputMode;
        unsigned long status;
}
PropMotifWmHints;

typedef struct
{
        uint32 red;
        uint32 green;
        uint32 blue;
}
PixelColour;


#define FILL_RECTANGLE(x,y,cx,cy)\
{ \
        XFillRectangle(g_display, g_wnd, g_gc, x, y, cx, cy); \
        if (g_ownbackstore) \
                XFillRectangle(g_display, g_backstore, g_gc, x, y, cx, cy); \
}

#define FILL_RECTANGLE_BACKSTORE(x,y,cx,cy)\
{ \
        XFillRectangle(g_display, g_ownbackstore ? g_backstore : g_wnd, g_gc, x, y, cx, cy); \
}

#define FILL_POLYGON(p,np)\
{ \
        XFillPolygon(g_display, g_wnd, g_gc, p, np, Complex, CoordModePrevious); \
        if (g_ownbackstore) \
                XFillPolygon(g_display, g_backstore, g_gc, p, np, Complex, CoordModePrevious); \
}

#define DRAW_ELLIPSE(x,y,cx,cy,m)\
{ \
        switch (m) \
        { \
                case 0: /* Outline */ \
                        XDrawArc(g_display, g_wnd, g_gc, x, y, cx, cy, 0, 360*64); \
                        if (g_ownbackstore) \
                                XDrawArc(g_display, g_backstore, g_gc, x, y, cx, cy, 0, 360*64); \
                        break; \
                case 1: /* Filled */ \
                        XFillArc(g_display, g_wnd, g_gc, x, y, cx, cy, 0, 360*64); \
                        if (g_ownbackstore) \
                                XFillArc(g_display, g_backstore, g_gc, x, y, cx, cy, 0, 360*64); \
                        break; \
        } \
}

/* colour maps */
extern BOOL g_owncolmap;
static Colormap g_xcolmap;
static uint32 *g_colmap = NULL;

#define TRANSLATE(col)          ( g_server_bpp != 8 ? translate_colour(col) : g_owncolmap ? col : g_colmap[col] )
#define SET_FOREGROUND(col)     XSetForeground(g_display, g_gc, TRANSLATE(col));
#define SET_BACKGROUND(col)     XSetBackground(g_display, g_gc, TRANSLATE(col));

static int rop2_map[] = {
        GXclear,                /* 0 */
        GXnor,                  /* DPon */
        GXandInverted,          /* DPna */
        GXcopyInverted,         /* Pn */
        GXandReverse,           /* PDna */
        GXinvert,               /* Dn */
        GXxor,                  /* DPx */
        GXnand,                 /* DPan */
        GXand,                  /* DPa */
        GXequiv,                /* DPxn */
        GXnoop,                 /* D */
        GXorInverted,           /* DPno */
        GXcopy,                 /* P */
        GXorReverse,            /* PDno */
        GXor,                   /* DPo */
        GXset                   /* 1 */
};

#define SET_FUNCTION(rop2)      { if (rop2 != ROP2_COPY) XSetFunction(g_display, g_gc, rop2_map[rop2]); }
#define RESET_FUNCTION(rop2)    { if (rop2 != ROP2_COPY) XSetFunction(g_display, g_gc, GXcopy); }

static void
mwm_hide_decorations(void)
{
        PropMotifWmHints motif_hints;
        Atom hintsatom;

        /* setup the property */
        motif_hints.flags = MWM_HINTS_DECORATIONS;
        motif_hints.decorations = 0;

        /* get the atom for the property */
        hintsatom = XInternAtom(g_display, "_MOTIF_WM_HINTS", False);
        if (!hintsatom)
        {
                warning("Failed to get atom _MOTIF_WM_HINTS: probably your window manager does not support MWM hints\n");
                return;
        }

        XChangeProperty(g_display, g_wnd, hintsatom, hintsatom, 32, PropModeReplace,
                        (unsigned char *) &motif_hints, PROP_MOTIF_WM_HINTS_ELEMENTS);
}

#define SPLITCOLOUR15(colour, rv) \
{ \
        rv.red = ((colour >> 7) & 0xf8) | ((colour >> 12) & 0x7); \
        rv.green = ((colour >> 2) & 0xf8) | ((colour >> 8) & 0x7); \
        rv.blue = ((colour << 3) & 0xf8) | ((colour >> 2) & 0x7); \
}

#define SPLITCOLOUR16(colour, rv) \
{ \
        rv.red = ((colour >> 8) & 0xf8) | ((colour >> 13) & 0x7); \
        rv.green = ((colour >> 3) & 0xfc) | ((colour >> 9) & 0x3); \
        rv.blue = ((colour << 3) & 0xf8) | ((colour >> 2) & 0x7); \
} \

#define SPLITCOLOUR24(colour, rv) \
{ \
        rv.blue = (colour & 0xff0000) >> 16; \
        rv.green = (colour & 0x00ff00) >> 8; \
        rv.red = (colour & 0x0000ff); \
}

#define MAKECOLOUR(pc) \
        ((pc.red >> g_red_shift_r) << g_red_shift_l) \
                | ((pc.green >> g_green_shift_r) << g_green_shift_l) \
                | ((pc.blue >> g_blue_shift_r) << g_blue_shift_l) \

#define BSWAP16(x) { x = (((x & 0xff) << 8) | (x >> 8)); }
#define BSWAP24(x) { x = (((x & 0xff) << 16) | (x >> 16) | (x & 0xff00)); }
#define BSWAP32(x) { x = (((x & 0xff00ff) << 8) | ((x >> 8) & 0xff00ff)); \
                        x = (x << 16) | (x >> 16); }

#define BOUT16(o, x) { *(o++) = x >> 8; *(o++) = x; }
#define BOUT24(o, x) { *(o++) = x >> 16; *(o++) = x >> 8; *(o++) = x; }
#define BOUT32(o, x) { *(o++) = x >> 24; *(o++) = x >> 16; *(o++) = x >> 8; *(o++) = x; }
#define LOUT16(o, x) { *(o++) = x; *(o++) = x >> 8; }
#define LOUT24(o, x) { *(o++) = x; *(o++) = x >> 8; *(o++) = x >> 16; }
#define LOUT32(o, x) { *(o++) = x; *(o++) = x >> 8; *(o++) = x >> 16; *(o++) = x >> 24; }

static uint32
translate_colour(uint32 colour)
{
        PixelColour pc;
        switch (g_server_bpp)
        {
                case 15:
                        SPLITCOLOUR15(colour, pc);
                        break;
                case 16:
                        SPLITCOLOUR16(colour, pc);
                        break;
                case 24:
                        SPLITCOLOUR24(colour, pc);
                        break;
        }
        return MAKECOLOUR(pc);
}

/* indent is confused by UNROLL8 */
/* *INDENT-OFF* */

/* repeat and unroll, similar to bitmap.c */
/* potentialy any of the following translate */
/* functions can use repeat but just doing */
/* the most common ones */

#define UNROLL8(stm) { stm stm stm stm stm stm stm stm }
/* 2 byte output repeat */
#define REPEAT2(stm) \
{ \
        while (out <= end - 8 * 2) \
                UNROLL8(stm) \
        while (out < end) \
                { stm } \
}
/* 3 byte output repeat */
#define REPEAT3(stm) \
{ \
        while (out <= end - 8 * 3) \
                UNROLL8(stm) \
        while (out < end) \
                { stm } \
}
/* 4 byte output repeat */
#define REPEAT4(stm) \
{ \
        while (out <= end - 8 * 4) \
                UNROLL8(stm) \
        while (out < end) \
                { stm } \
}
/* *INDENT-ON* */

static void
translate8to8(const uint8 * data, uint8 * out, uint8 * end)
{
        while (out < end)
                *(out++) = (uint8) g_colmap[*(data++)];
}

static void
translate8to16(const uint8 * data, uint8 * out, uint8 * end)
{
        uint16 value;

        if (g_arch_match)
        {
                /* *INDENT-OFF* */
                REPEAT2
                (
                        *((uint16 *) out) = g_colmap[*(data++)];
                        out += 2;
                )
                /* *INDENT-ON* */
        }
        else if (g_xserver_be)
        {
                while (out < end)
                {
                        value = (uint16) g_colmap[*(data++)];
                        BOUT16(out, value);
                }
        }
        else
        {
                while (out < end)
                {
                        value = (uint16) g_colmap[*(data++)];
                        LOUT16(out, value);
                }
        }
}

/* little endian - conversion happens when colourmap is built */
static void
translate8to24(const uint8 * data, uint8 * out, uint8 * end)
{
        uint32 value;

        if (g_xserver_be)
        {
                while (out < end)
                {
                        value = g_colmap[*(data++)];
                        BOUT24(out, value);
                }
        }
        else
        {
                while (out < end)
                {
                        value = g_colmap[*(data++)];
                        LOUT24(out, value);
                }
        }
}

static void
translate8to32(const uint8 * data, uint8 * out, uint8 * end)
{
        uint32 value;

        if (g_arch_match)
        {
                /* *INDENT-OFF* */
                REPEAT4
                (
                        *((uint32 *) out) = g_colmap[*(data++)];
                        out += 4;
                )
                /* *INDENT-ON* */
        }
        else if (g_xserver_be)
        {
                while (out < end)
                {
                        value = g_colmap[*(data++)];
                        BOUT32(out, value);
                }
        }
        else
        {
                while (out < end)
                {
                        value = g_colmap[*(data++)];
                        LOUT32(out, value);
                }
        }
}

static void
translate15to16(const uint16 * data, uint8 * out, uint8 * end)
{
        uint16 pixel;
        uint16 value;
        PixelColour pc;

        if (g_xserver_be)
        {
                while (out < end)
                {
                        pixel = *(data++);
                        if (g_host_be)
                        {
                                BSWAP16(pixel);
                        }
                        SPLITCOLOUR15(pixel, pc);
                        value = MAKECOLOUR(pc);
                        BOUT16(out, value);
                }
        }
        else
        {
                while (out < end)
                {
                        pixel = *(data++);
                        if (g_host_be)
                        {
                                BSWAP16(pixel);
                        }
                        SPLITCOLOUR15(pixel, pc);
                        value = MAKECOLOUR(pc);
                        LOUT16(out, value);
                }
        }
}

static void
translate15to24(const uint16 * data, uint8 * out, uint8 * end)
{
        uint32 value;
        uint16 pixel;
        PixelColour pc;

        if (g_arch_match)
        {
                /* *INDENT-OFF* */
                REPEAT3
                (
                        pixel = *(data++);
                        SPLITCOLOUR15(pixel, pc);
                        *(out++) = pc.blue;
                        *(out++) = pc.green;
                        *(out++) = pc.red;
                )
                /* *INDENT-ON* */
        }
        else if (g_xserver_be)
        {
                while (out < end)
                {
                        pixel = *(data++);
                        if (g_host_be)
                        {
                                BSWAP16(pixel);
                        }
                        SPLITCOLOUR15(pixel, pc);
                        value = MAKECOLOUR(pc);
                        BOUT24(out, value);
                }
        }
        else
        {
                while (out < end)
                {
                        pixel = *(data++);
                        if (g_host_be)
                        {
                                BSWAP16(pixel);
                        }
                        SPLITCOLOUR15(pixel, pc);
                        value = MAKECOLOUR(pc);
                        LOUT24(out, value);
                }
        }
}

static void
translate15to32(const uint16 * data, uint8 * out, uint8 * end)
{
        uint16 pixel;
        uint32 value;
        PixelColour pc;

        if (g_arch_match)
        {
                /* *INDENT-OFF* */
                REPEAT4
                (
                        pixel = *(data++);
                        SPLITCOLOUR15(pixel, pc);
                        *(out++) = pc.blue;
                        *(out++) = pc.green;
                        *(out++) = pc.red;
                        *(out++) = 0;
                )
                /* *INDENT-ON* */
        }
        else if (g_xserver_be)
        {
                while (out < end)
                {
                        pixel = *(data++);
                        if (g_host_be)
                        {
                                BSWAP16(pixel);
                        }
                        SPLITCOLOUR15(pixel, pc);
                        value = MAKECOLOUR(pc);
                        BOUT32(out, value);
                }
        }
        else
        {
                while (out < end)
                {
                        pixel = *(data++);
                        if (g_host_be)
                        {
                                BSWAP16(pixel);
                        }
                        SPLITCOLOUR15(pixel, pc);
                        value = MAKECOLOUR(pc);
                        LOUT32(out, value);
                }
        }
}

static void
translate16to16(const uint16 * data, uint8 * out, uint8 * end)
{
        uint16 pixel;
        uint16 value;
        PixelColour pc;

        if (g_xserver_be)
        {
                if (g_host_be)
                {
                        while (out < end)
                        {
                                pixel = *(data++);
                                BSWAP16(pixel);
                                SPLITCOLOUR16(pixel, pc);
                                value = MAKECOLOUR(pc);
                                BOUT16(out, value);
                        }
                }
                else
                {
                        while (out < end)
                        {
                                pixel = *(data++);
                                SPLITCOLOUR16(pixel, pc);
                                value = MAKECOLOUR(pc);
                                BOUT16(out, value);
                        }
                }
        }
        else
        {
                if (g_host_be)
                {
                        while (out < end)
                        {
                                pixel = *(data++);
                                BSWAP16(pixel);
                                SPLITCOLOUR16(pixel, pc);
                                value = MAKECOLOUR(pc);
                                LOUT16(out, value);
                        }
                }
                else
                {
                        while (out < end)
                        {
                                pixel = *(data++);
                                SPLITCOLOUR16(pixel, pc);
                                value = MAKECOLOUR(pc);
                                LOUT16(out, value);
                        }
                }
        }
}

static void
translate16to24(const uint16 * data, uint8 * out, uint8 * end)
{
        uint32 value;
        uint16 pixel;
        PixelColour pc;

        if (g_arch_match)
        {
                /* *INDENT-OFF* */
                REPEAT3
                (
                        pixel = *(data++);
                        SPLITCOLOUR16(pixel, pc);
                        *(out++) = pc.blue;
                        *(out++) = pc.green;
                        *(out++) = pc.red;
                )
                /* *INDENT-ON* */
        }
        else if (g_xserver_be)
        {
                if (g_host_be)
                {
                        while (out < end)
                        {
                                pixel = *(data++);
                                BSWAP16(pixel);
                                SPLITCOLOUR16(pixel, pc);
                                value = MAKECOLOUR(pc);
                                BOUT24(out, value);
                        }
                }
                else
                {
                        while (out < end)
                        {
                                pixel = *(data++);
                                SPLITCOLOUR16(pixel, pc);
                                value = MAKECOLOUR(pc);
                                BOUT24(out, value);
                        }
                }
        }
        else
        {
                if (g_host_be)
                {
                        while (out < end)
                        {
                                pixel = *(data++);
                                BSWAP16(pixel);
                                SPLITCOLOUR16(pixel, pc);
                                value = MAKECOLOUR(pc);
                                LOUT24(out, value);
                        }
                }
                else
                {
                        while (out < end)
                        {
                                pixel = *(data++);
                                SPLITCOLOUR16(pixel, pc);
                                value = MAKECOLOUR(pc);
                                LOUT24(out, value);
                        }
                }
        }
}

static void
translate16to32(const uint16 * data, uint8 * out, uint8 * end)
{
        uint16 pixel;
        uint32 value;
        PixelColour pc;

        if (g_arch_match)
        {
                /* *INDENT-OFF* */
                REPEAT4
                (
                        pixel = *(data++);
                        SPLITCOLOUR16(pixel, pc);
                        *(out++) = pc.blue;
                        *(out++) = pc.green;
                        *(out++) = pc.red;
                        *(out++) = 0;
                )
                /* *INDENT-ON* */
        }
        else if (g_xserver_be)
        {
                if (g_host_be)
                {
                        while (out < end)
                        {
                                pixel = *(data++);
                                BSWAP16(pixel);
                                SPLITCOLOUR16(pixel, pc);
                                value = MAKECOLOUR(pc);
                                BOUT32(out, value);
                        }
                }
                else
                {
                        while (out < end)
                        {
                                pixel = *(data++);
                                SPLITCOLOUR16(pixel, pc);
                                value = MAKECOLOUR(pc);
                                BOUT32(out, value);
                        }
                }
        }
        else
        {
                if (g_host_be)
                {
                        while (out < end)
                        {
                                pixel = *(data++);
                                BSWAP16(pixel);
                                SPLITCOLOUR16(pixel, pc);
                                value = MAKECOLOUR(pc);
                                LOUT32(out, value);
                        }
                }
                else
                {
                        while (out < end)
                        {
                                pixel = *(data++);
                                SPLITCOLOUR16(pixel, pc);
                                value = MAKECOLOUR(pc);
                                LOUT32(out, value);
                        }
                }
        }
}

static void
translate24to16(const uint8 * data, uint8 * out, uint8 * end)
{
        uint32 pixel = 0;
        uint16 value;
        PixelColour pc;

        while (out < end)
        {
                pixel = *(data++) << 16;
                pixel |= *(data++) << 8;
                pixel |= *(data++);
                SPLITCOLOUR24(pixel, pc);
                value = MAKECOLOUR(pc);
                if (g_xserver_be)
                {
                        BOUT16(out, value);
                }
                else
                {
                        LOUT16(out, value);
                }
        }
}

static void
translate24to24(const uint8 * data, uint8 * out, uint8 * end)
{
        uint32 pixel;
        uint32 value;
        PixelColour pc;

        if (g_xserver_be)
        {
                while (out < end)
                {
                        pixel = *(data++) << 16;
                        pixel |= *(data++) << 8;
                        pixel |= *(data++);
                        SPLITCOLOUR24(pixel, pc);
                        value = MAKECOLOUR(pc);
                        BOUT24(out, value);
                }
        }
        else
        {
                while (out < end)
                {
                        pixel = *(data++) << 16;
                        pixel |= *(data++) << 8;
                        pixel |= *(data++);
                        SPLITCOLOUR24(pixel, pc);
                        value = MAKECOLOUR(pc);
                        LOUT24(out, value);
                }
        }
}

static void
translate24to32(const uint8 * data, uint8 * out, uint8 * end)
{
        uint32 pixel;
        uint32 value;
        PixelColour pc;

        if (g_arch_match)
        {
                /* *INDENT-OFF* */
#ifdef NEED_ALIGN
                REPEAT4
                (
                        *(out++) = *(data++);
                        *(out++) = *(data++);
                        *(out++) = *(data++);
                        *(out++) = 0;
                )
#else
                REPEAT4
                (
                 /* Only read 3 bytes. Reading 4 bytes means reading beyound buffer. */
                 *((uint32 *) out) = *((uint16 *) data) + (*((uint8 *) data + 2) << 16);
                 out += 4;
                 data += 3;
                )
#endif
                /* *INDENT-ON* */
        }
        else if (g_xserver_be)
        {
                while (out < end)
                {
                        pixel = *(data++) << 16;
                        pixel |= *(data++) << 8;
                        pixel |= *(data++);
                        SPLITCOLOUR24(pixel, pc);
                        value = MAKECOLOUR(pc);
                        BOUT32(out, value);
                }
        }
        else
        {
                while (out < end)
                {
                        pixel = *(data++) << 16;
                        pixel |= *(data++) << 8;
                        pixel |= *(data++);
                        SPLITCOLOUR24(pixel, pc);
                        value = MAKECOLOUR(pc);
                        LOUT32(out, value);
                }
        }
}

static uint8 *
translate_image(int width, int height, uint8 * data)
{
        int size;
        uint8 *out;
        uint8 *end;

        /* if server and xserver bpp match, */
        /* and arch(endian) matches, no need to translate */
        /* just return data */
        if (g_arch_match)
        {
                if (g_depth == 15 && g_server_bpp == 15)
                        return data;
                if (g_depth == 16 && g_server_bpp == 16)
                        return data;
                if (g_depth == 24 && g_bpp == 24 && g_server_bpp == 24)
                        return data;
        }

        size = width * height * (g_bpp / 8);
        out = (uint8 *) xmalloc(size);
        end = out + size;

        switch (g_server_bpp)
        {
                case 24:
                        switch (g_bpp)
                        {
                                case 32:
                                        translate24to32(data, out, end);
                                        break;
                                case 24:
                                        translate24to24(data, out, end);
                                        break;
                                case 16:
                                        translate24to16(data, out, end);
                                        break;
                        }
                        break;
                case 16:
                        switch (g_bpp)
                        {
                                case 32:
                                        translate16to32((uint16 *) data, out, end);
                                        break;
                                case 24:
                                        translate16to24((uint16 *) data, out, end);
                                        break;
                                case 16:
                                        translate16to16((uint16 *) data, out, end);
                                        break;
                        }
                        break;
                case 15:
                        switch (g_bpp)
                        {
                                case 32:
                                        translate15to32((uint16 *) data, out, end);
                                        break;
                                case 24:
                                        translate15to24((uint16 *) data, out, end);
                                        break;
                                case 16:
                                        translate15to16((uint16 *) data, out, end);
                                        break;
                        }
                        break;
                case 8:
                        switch (g_bpp)
                        {
                                case 8:
                                        translate8to8(data, out, end);
                                        break;
                                case 16:
                                        translate8to16(data, out, end);
                                        break;
                                case 24:
                                        translate8to24(data, out, end);
                                        break;
                                case 32:
                                        translate8to32(data, out, end);
                                        break;
                        }
                        break;
        }
        return out;
}

BOOL
get_key_state(unsigned int state, uint32 keysym)
{
        int modifierpos, key, keysymMask = 0;
        int offset;

        KeyCode keycode = XKeysymToKeycode(g_display, keysym);

        if (keycode == NoSymbol)
                return False;

        for (modifierpos = 0; modifierpos < 8; modifierpos++)
        {
                offset = g_mod_map->max_keypermod * modifierpos;

                for (key = 0; key < g_mod_map->max_keypermod; key++)
                {
                        if (g_mod_map->modifiermap[offset + key] == keycode)
                                keysymMask |= 1 << modifierpos;
                }
        }

        return (state & keysymMask) ? True : False;
}

static void
calculate_shifts(uint32 mask, int *shift_r, int *shift_l)
{
        *shift_l = ffs(mask) - 1;
        mask >>= *shift_l;
        *shift_r = 8 - ffs(mask & ~(mask >> 1));
}

BOOL
ui_init(void)
{
        XVisualInfo vi;
        XPixmapFormatValues *pfm;
        uint16 test;
        int i, screen_num, nvisuals;
        XVisualInfo *vmatches = NULL;
        XVisualInfo template;
        Bool TrueColorVisual = False;

        g_display = XOpenDisplay(NULL);
        if (g_display == NULL)
        {
                error("Failed to open display: %s\n", XDisplayName(NULL));
                return False;
        }

        screen_num = DefaultScreen(g_display);
        g_x_socket = ConnectionNumber(g_display);
        g_screen = ScreenOfDisplay(g_display, screen_num);
        g_depth = DefaultDepthOfScreen(g_screen);

        /* Search for best TrueColor depth */
        template.class = TrueColor;
        vmatches = XGetVisualInfo(g_display, VisualClassMask, &template, &nvisuals);

        nvisuals--;
        while (nvisuals >= 0)
        {
                if ((vmatches + nvisuals)->depth > g_depth)
                {
                        g_depth = (vmatches + nvisuals)->depth;
                }
                nvisuals--;
                TrueColorVisual = True;
        }

        test = 1;
        g_host_be = !(BOOL) (*(uint8 *) (&test));
        g_xserver_be = (ImageByteOrder(g_display) == MSBFirst);

        if ((g_server_bpp == 8) && ((!TrueColorVisual) || (g_depth <= 8)))
        {
                /* we use a colourmap, so the default visual should do */
                g_visual = DefaultVisualOfScreen(g_screen);
                g_depth = DefaultDepthOfScreen(g_screen);

                /* Do not allocate colours on a TrueColor visual */
                if (g_visual->class == TrueColor)
                {
                        g_owncolmap = False;
                }
        }
        else
        {
                /* need a truecolour visual */
                if (!XMatchVisualInfo(g_display, screen_num, g_depth, TrueColor, &vi))
                {
                        error("The display does not support true colour - high colour support unavailable.\n");
                        return False;
                }

                g_visual = vi.visual;
                g_owncolmap = False;
                calculate_shifts(vi.red_mask, &g_red_shift_r, &g_red_shift_l);
                calculate_shifts(vi.blue_mask, &g_blue_shift_r, &g_blue_shift_l);
                calculate_shifts(vi.green_mask, &g_green_shift_r, &g_green_shift_l);

                /* if RGB video and everything is little endian */
                if ((vi.red_mask > vi.green_mask && vi.green_mask > vi.blue_mask) &&
                    !g_xserver_be && !g_host_be)
                {
                        if (g_depth <= 16 || (g_red_shift_l == 16 && g_green_shift_l == 8 &&
                                              g_blue_shift_l == 0))
                        {
                                g_arch_match = True;
                        }
                }

                if (g_arch_match)
                {
                        DEBUG(("Architectures match, enabling little endian optimisations.\n"));
                }
        }

        pfm = XListPixmapFormats(g_display, &i);
        if (pfm != NULL)
        {
                /* Use maximum bpp for this depth - this is generally
                   desirable, e.g. 24 bits->32 bits. */
                while (i--)
                {
                        if ((pfm[i].depth == g_depth) && (pfm[i].bits_per_pixel > g_bpp))
                        {
                                g_bpp = pfm[i].bits_per_pixel;
                        }
                }
                XFree(pfm);
        }

        if (g_bpp < 8)
        {
                error("Less than 8 bpp not currently supported.\n");
                XCloseDisplay(g_display);
                return False;
        }

        if (!g_owncolmap)
        {
                g_xcolmap =
                        XCreateColormap(g_display, RootWindowOfScreen(g_screen), g_visual,
                                        AllocNone);
                if (g_depth <= 8)
                        warning("Screen depth is 8 bits or lower: you may want to use -C for a private colourmap\n");
        }

        if ((!g_ownbackstore) && (DoesBackingStore(g_screen) != Always))
        {
                warning("External BackingStore not available, using internal\n");
                g_ownbackstore = True;
        }

        /*
         * Determine desktop size
         */
        if (g_fullscreen)
        {
                g_width = WidthOfScreen(g_screen);
                g_height = HeightOfScreen(g_screen);
        }
        else if (g_width < 0)
        {
                /* Percent of screen */
                if (-g_width >= 100)
                        g_using_full_workarea = True;
                g_height = HeightOfScreen(g_screen) * (-g_width) / 100;
                g_width = WidthOfScreen(g_screen) * (-g_width) / 100;
        }
        else if (g_width == 0)
        {
                /* Fetch geometry from _NET_WORKAREA */
                uint32 x, y, cx, cy;
                g_using_full_workarea = True;

                if (get_current_workarea(&x, &y, &cx, &cy) == 0)
                {
                        g_width = cx;
                        g_height = cy;
                }
                else
                {
                        warning("Failed to get workarea: probably your window manager does not support extended hints\n");
                        g_width = 800;
                        g_height = 600;
                }
        }

        /* make sure width is a multiple of 4 */
        g_width = (g_width + 3) & ~3;

        g_mod_map = XGetModifierMapping(g_display);

        xkeymap_init();

        if (g_enable_compose)
                g_IM = XOpenIM(g_display, NULL, NULL, NULL);

        xclip_init();

        DEBUG_RDP5(("server bpp %d client bpp %d depth %d\n", g_server_bpp, g_bpp, g_depth));

        return True;
}

void
ui_deinit(void)
{
        if (g_IM != NULL)
                XCloseIM(g_IM);

        if (g_null_cursor != NULL)
                ui_destroy_cursor(g_null_cursor);

        XFreeModifiermap(g_mod_map);

        if (g_ownbackstore)
                XFreePixmap(g_display, g_backstore);

        XFreeGC(g_display, g_gc);
        XCloseDisplay(g_display);
        g_display = NULL;
}

BOOL
ui_create_window(void)
{
        uint8 null_pointer_mask[1] = { 0x80 };
        uint8 null_pointer_data[24] = { 0x00 };

        XSetWindowAttributes attribs;
        XClassHint *classhints;
        XSizeHints *sizehints;
        int wndwidth, wndheight;
        long input_mask, ic_input_mask;
        XEvent xevent;

        wndwidth = g_fullscreen ? WidthOfScreen(g_screen) : g_width;
        wndheight = g_fullscreen ? HeightOfScreen(g_screen) : g_height;

        /* Handle -x-y portion of geometry string */
        if (g_xpos < 0 || (g_xpos == 0 && (g_pos & 2)))
                g_xpos = WidthOfScreen(g_screen) + g_xpos - g_width;
        if (g_ypos < 0 || (g_ypos == 0 && (g_pos & 4)))
                g_ypos = HeightOfScreen(g_screen) + g_ypos - g_height;

        attribs.background_pixel = BlackPixelOfScreen(g_screen);
        attribs.border_pixel = WhitePixelOfScreen(g_screen);
        attribs.backing_store = g_ownbackstore ? NotUseful : Always;
        attribs.override_redirect = g_fullscreen;
        attribs.colormap = g_xcolmap;

        g_wnd = XCreateWindow(g_display, RootWindowOfScreen(g_screen), g_xpos, g_ypos, wndwidth,
                              wndheight, 0, g_depth, InputOutput, g_visual,
                              CWBackPixel | CWBackingStore | CWOverrideRedirect | CWColormap |
                              CWBorderPixel, &attribs);

        if (g_gc == NULL)
                g_gc = XCreateGC(g_display, g_wnd, 0, NULL);

        if (g_create_bitmap_gc == NULL)
                g_create_bitmap_gc = XCreateGC(g_display, g_wnd, 0, NULL);

        if ((g_ownbackstore) && (g_backstore == 0))
        {
                g_backstore = XCreatePixmap(g_display, g_wnd, g_width, g_height, g_depth);

                /* clear to prevent rubbish being exposed at startup */
                XSetForeground(g_display, g_gc, BlackPixelOfScreen(g_screen));
                XFillRectangle(g_display, g_backstore, g_gc, 0, 0, g_width, g_height);
        }

        XStoreName(g_display, g_wnd, g_title);

        if (g_hide_decorations)
                mwm_hide_decorations();

        classhints = XAllocClassHint();
        if (classhints != NULL)
        {
                classhints->res_name = classhints->res_class = "rdesktop";
                XSetClassHint(g_display, g_wnd, classhints);
                XFree(classhints);
        }

        sizehints = XAllocSizeHints();
        if (sizehints)
        {
                sizehints->flags = PMinSize | PMaxSize;
                if (g_pos)
                        sizehints->flags |= PPosition;
                sizehints->min_width = sizehints->max_width = g_width;
                sizehints->min_height = sizehints->max_height = g_height;
                XSetWMNormalHints(g_display, g_wnd, sizehints);
                XFree(sizehints);
        }

        if (g_embed_wnd)
        {
                XReparentWindow(g_display, g_wnd, (Window) g_embed_wnd, 0, 0);
        }

        input_mask = KeyPressMask | KeyReleaseMask | ButtonPressMask | ButtonReleaseMask |
                VisibilityChangeMask | FocusChangeMask | StructureNotifyMask;

        if (g_sendmotion)
                input_mask |= PointerMotionMask;
        if (g_ownbackstore)
                input_mask |= ExposureMask;
        if (g_fullscreen || g_grab_keyboard)
                input_mask |= EnterWindowMask;
        if (g_grab_keyboard)
                input_mask |= LeaveWindowMask;

        if (g_IM != NULL)
        {
                g_IC = XCreateIC(g_IM, XNInputStyle, (XIMPreeditNothing | XIMStatusNothing),
                                 XNClientWindow, g_wnd, XNFocusWindow, g_wnd, NULL);

                if ((g_IC != NULL)
                    && (XGetICValues(g_IC, XNFilterEvents, &ic_input_mask, NULL) == NULL))
                        input_mask |= ic_input_mask;
        }

        XSelectInput(g_display, g_wnd, input_mask);
        XMapWindow(g_display, g_wnd);

        /* wait for VisibilityNotify */
        do
        {
                XMaskEvent(g_display, VisibilityChangeMask, &xevent);
        }
        while (xevent.type != VisibilityNotify);
        g_Unobscured = xevent.xvisibility.state == VisibilityUnobscured;

        g_focused = False;
        g_mouse_in_wnd = False;

        /* handle the WM_DELETE_WINDOW protocol */
        g_protocol_atom = XInternAtom(g_display, "WM_PROTOCOLS", True);
        g_kill_atom = XInternAtom(g_display, "WM_DELETE_WINDOW", True);
        XSetWMProtocols(g_display, g_wnd, &g_kill_atom, 1);

        /* create invisible 1x1 cursor to be used as null cursor */
        if (g_null_cursor == NULL)
                g_null_cursor = ui_create_cursor(0, 0, 1, 1, null_pointer_mask, null_pointer_data);

        return True;
}

void
ui_resize_window()
{
        XSizeHints *sizehints;
        Pixmap bs;

        sizehints = XAllocSizeHints();
        if (sizehints)
        {
                sizehints->flags = PMinSize | PMaxSize;
                sizehints->min_width = sizehints->max_width = g_width;
                sizehints->min_height = sizehints->max_height = g_height;
                XSetWMNormalHints(g_display, g_wnd, sizehints);
                XFree(sizehints);
        }

        if (!(g_fullscreen || g_embed_wnd))
        {
                XResizeWindow(g_display, g_wnd, g_width, g_height);
        }

        /* create new backstore pixmap */
        if (g_backstore != 0)
        {
                bs = XCreatePixmap(g_display, g_wnd, g_width, g_height, g_depth);
                XSetForeground(g_display, g_gc, BlackPixelOfScreen(g_screen));
                XFillRectangle(g_display, bs, g_gc, 0, 0, g_width, g_height);
                XCopyArea(g_display, g_backstore, bs, g_gc, 0, 0, g_width, g_height, 0, 0);
                XFreePixmap(g_display, g_backstore);
                g_backstore = bs;
        }
}

void
ui_destroy_window(void)
{
        if (g_IC != NULL)
                XDestroyIC(g_IC);

        XDestroyWindow(g_display, g_wnd);
}

void
xwin_toggle_fullscreen(void)
{
        Pixmap contents = 0;

        if (!g_ownbackstore)
        {
                /* need to save contents of window */
                contents = XCreatePixmap(g_display, g_wnd, g_width, g_height, g_depth);
                XCopyArea(g_display, g_wnd, contents, g_gc, 0, 0, g_width, g_height, 0, 0);
        }

        ui_destroy_window();
        g_fullscreen = !g_fullscreen;
        ui_create_window();

        XDefineCursor(g_display, g_wnd, g_current_cursor);

        if (!g_ownbackstore)
        {
                XCopyArea(g_display, contents, g_wnd, g_gc, 0, 0, g_width, g_height, 0, 0);
                XFreePixmap(g_display, contents);
        }
}

static void
handle_button_event(XEvent xevent, BOOL down)
{
        uint16 button, flags = 0;
        g_last_gesturetime = xevent.xbutton.time;
        button = xkeymap_translate_button(xevent.xbutton.button);
        if (button == 0)
                return;

        if (down)
                flags = MOUSE_FLAG_DOWN;

        /* Stop moving window when button is released, regardless of cursor position */
        if (g_moving_wnd && (xevent.type == ButtonRelease))
                g_moving_wnd = False;

        /* If win_button_size is nonzero, enable single app mode */
        if (xevent.xbutton.y < g_win_button_size)
        {
                /*  Check from right to left: */
                if (xevent.xbutton.x >= g_width - g_win_button_size)
                {
                        /* The close button, continue */
                        ;
                }
                else if (xevent.xbutton.x >= g_width - g_win_button_size * 2)
                {
                        /* The maximize/restore button. Do not send to
                           server.  It might be a good idea to change the
                           cursor or give some other visible indication
                           that rdesktop inhibited this click */
                        if (xevent.type == ButtonPress)
                                return;
                }
                else if (xevent.xbutton.x >= g_width - g_win_button_size * 3)
                {
                        /* The minimize button. Iconify window. */
                        if (xevent.type == ButtonRelease)
                        {
                                /* Release the mouse button outside the minimize button, to prevent the
                                   actual minimazation to happen */
                                rdp_send_input(time(NULL), RDP_INPUT_MOUSE, button, 1, 1);
                                XIconifyWindow(g_display, g_wnd, DefaultScreen(g_display));
                                return;
                        }
                }
                else if (xevent.xbutton.x <= g_win_button_size)
                {
                        /* The system menu. Ignore. */
                        if (xevent.type == ButtonPress)
                                return;
                }
                else
                {
                        /* The title bar. */
                        if (xevent.type == ButtonPress)
                        {
                                if (!g_fullscreen && g_hide_decorations && !g_using_full_workarea)
                                {
                                        g_moving_wnd = True;
                                        g_move_x_offset = xevent.xbutton.x;
                                        g_move_y_offset = xevent.xbutton.y;
                                }
                                return;
                        }
                }
        }

        rdp_send_input(time(NULL), RDP_INPUT_MOUSE,
                       flags | button, xevent.xbutton.x, xevent.xbutton.y);
}

/* Process events in Xlib queue
   Returns 0 after user quit, 1 otherwise */
static int
xwin_process_events(void)
{
        XEvent xevent;
        KeySym keysym;
        uint32 ev_time;
        char str[256];
        Status status;
        int events = 0;

        while ((XPending(g_display) > 0) && events++ < 20)
        {
                XNextEvent(g_display, &xevent);

                if ((g_IC != NULL) && (XFilterEvent(&xevent, None) == True))
                {
                        DEBUG_KBD(("Filtering event\n"));
                        continue;
                }

                switch (xevent.type)
                {
                        case VisibilityNotify:
                                g_Unobscured = xevent.xvisibility.state == VisibilityUnobscured;
                                break;
                        case ClientMessage:
                                /* the window manager told us to quit */
                                if ((xevent.xclient.message_type == g_protocol_atom)
                                    && ((Atom) xevent.xclient.data.l[0] == g_kill_atom))
                                        /* Quit */
                                        return 0;
                                break;

                        case KeyPress:
                                g_last_gesturetime = xevent.xkey.time;
                                if (g_IC != NULL)
                                        /* Multi_key compatible version */
                                {
                                        XmbLookupString(g_IC,
                                                        &xevent.xkey, str, sizeof(str), &keysym,
                                                        &status);
                                        if (!((status == XLookupKeySym) || (status == XLookupBoth)))
                                        {
                                                error("XmbLookupString failed with status 0x%x\n",
                                                      status);
                                                break;
                                        }
                                }
                                else
                                {
                                        /* Plain old XLookupString */
                                        DEBUG_KBD(("\nNo input context, using XLookupString\n"));
                                        XLookupString((XKeyEvent *) & xevent,
                                                      str, sizeof(str), &keysym, NULL);
                                }

                                DEBUG_KBD(("KeyPress for keysym (0x%lx, %s)\n", keysym,
                                           get_ksname(keysym)));

                                ev_time = time(NULL);
                                if (handle_special_keys(keysym, xevent.xkey.state, ev_time, True))
                                        break;

                                xkeymap_send_keys(keysym, xevent.xkey.keycode, xevent.xkey.state,
                                                  ev_time, True, 0);
                                break;

                        case KeyRelease:
                                g_last_gesturetime = xevent.xkey.time;
                                XLookupString((XKeyEvent *) & xevent, str,
                                              sizeof(str), &keysym, NULL);

                                DEBUG_KBD(("\nKeyRelease for keysym (0x%lx, %s)\n", keysym,
                                           get_ksname(keysym)));

                                ev_time = time(NULL);
                                if (handle_special_keys(keysym, xevent.xkey.state, ev_time, False))
                                        break;

                                xkeymap_send_keys(keysym, xevent.xkey.keycode, xevent.xkey.state,
                                                  ev_time, False, 0);
                                break;

                        case ButtonPress:
                                handle_button_event(xevent, True);
                                break;

                        case ButtonRelease:
                                handle_button_event(xevent, False);
                                break;

                        case MotionNotify:
                                if (g_moving_wnd)
                                {
                                        XMoveWindow(g_display, g_wnd,
                                                    xevent.xmotion.x_root - g_move_x_offset,
                                                    xevent.xmotion.y_root - g_move_y_offset);
                                        break;
                                }

                                if (g_fullscreen && !g_focused)
                                        XSetInputFocus(g_display, g_wnd, RevertToPointerRoot,
                                                       CurrentTime);
                                rdp_send_input(time(NULL), RDP_INPUT_MOUSE,
                                               MOUSE_FLAG_MOVE, xevent.xmotion.x, xevent.xmotion.y);
                                break;

                        case FocusIn:
                                if (xevent.xfocus.mode == NotifyGrab)
                                        break;
                                g_focused = True;
                                reset_modifier_keys();
                                if (g_grab_keyboard && g_mouse_in_wnd)
                                        XGrabKeyboard(g_display, g_wnd, True,
                                                      GrabModeAsync, GrabModeAsync, CurrentTime);
                                break;

                        case FocusOut:
                                if (xevent.xfocus.mode == NotifyUngrab)
                                        break;
                                g_focused = False;
                                if (xevent.xfocus.mode == NotifyWhileGrabbed)
                                        XUngrabKeyboard(g_display, CurrentTime);
                                break;

                        case EnterNotify:
                                /* we only register for this event when in fullscreen mode */
                                /* or grab_keyboard */
                                g_mouse_in_wnd = True;
                                if (g_fullscreen)
                                {
                                        XSetInputFocus(g_display, g_wnd, RevertToPointerRoot,
                                                       CurrentTime);
                                        break;
                                }
                                if (g_focused)
                                        XGrabKeyboard(g_display, g_wnd, True,
                                                      GrabModeAsync, GrabModeAsync, CurrentTime);
                                break;

                        case LeaveNotify:
                                /* we only register for this event when grab_keyboard */
                                g_mouse_in_wnd = False;
                                XUngrabKeyboard(g_display, CurrentTime);
                                break;

                        case Expose:
                                XCopyArea(g_display, g_backstore, g_wnd, g_gc,
                                          xevent.xexpose.x, xevent.xexpose.y,
                                          xevent.xexpose.width,
                                          xevent.xexpose.height,
                                          xevent.xexpose.x, xevent.xexpose.y);
                                break;

                        case MappingNotify:
                                /* Refresh keyboard mapping if it has changed. This is important for
                                   Xvnc, since it allocates keycodes dynamically */
                                if (xevent.xmapping.request == MappingKeyboard
                                    || xevent.xmapping.request == MappingModifier)
                                        XRefreshKeyboardMapping(&xevent.xmapping);

                                if (xevent.xmapping.request == MappingModifier)
                                {
                                        XFreeModifiermap(g_mod_map);
                                        g_mod_map = XGetModifierMapping(g_display);
                                }
                                break;

                                /* clipboard stuff */
                        case SelectionNotify:
                                xclip_handle_SelectionNotify(&xevent.xselection);
                                break;
                        case SelectionRequest:
                                xclip_handle_SelectionRequest(&xevent.xselectionrequest);
                                break;
                        case SelectionClear:
                                xclip_handle_SelectionClear();
                                break;
                        case PropertyNotify:
                                xclip_handle_PropertyNotify(&xevent.xproperty);
                                break;
                        case MapNotify:
                                rdp_send_client_window_status(1);
                                break;
                        case UnmapNotify:
                                rdp_send_client_window_status(0);
                                break;
                }
        }
        /* Keep going */
        return 1;
}

/* Returns 0 after user quit, 1 otherwise */
int
ui_select(int rdp_socket)
{
        int n;
        fd_set rfds, wfds;
        struct timeval tv;
        BOOL s_timeout = False;

        while (True)
        {
                n = (rdp_socket > g_x_socket) ? rdp_socket : g_x_socket;
                /* Process any events already waiting */
                if (!xwin_process_events())
                        /* User quit */
                        return 0;

                FD_ZERO(&rfds);
                FD_ZERO(&wfds);
                FD_SET(rdp_socket, &rfds);
                FD_SET(g_x_socket, &rfds);

#ifdef WITH_RDPSND
                /* FIXME: there should be an API for registering fds */
                if (g_dsp_busy)
                {
                        FD_SET(g_dsp_fd, &wfds);
                        n = (g_dsp_fd > n) ? g_dsp_fd : n;
                }
#endif
                /* default timeout */
                tv.tv_sec = 60;
                tv.tv_usec = 0;

                /* add redirection handles */
                rdpdr_add_fds(&n, &rfds, &wfds, &tv, &s_timeout);

                n++;

                switch (select(n, &rfds, &wfds, NULL, &tv))
                {
                        case -1:
                                error("select: %s\n", strerror(errno));

                        case 0:
                                /* Abort serial read calls */
                                if (s_timeout)
                                        rdpdr_check_fds(&rfds, &wfds, (BOOL) True);
                                continue;
                }

                rdpdr_check_fds(&rfds, &wfds, (BOOL) False);

                if (FD_ISSET(rdp_socket, &rfds))
                        return 1;

#ifdef WITH_RDPSND
                if (g_dsp_busy && FD_ISSET(g_dsp_fd, &wfds))
                        wave_out_play();
#endif
        }
}

void
ui_move_pointer(int x, int y)
{
        XWarpPointer(g_display, g_wnd, g_wnd, 0, 0, 0, 0, x, y);
}

HBITMAP
ui_create_bitmap(int width, int height, uint8 * data)
{
        XImage *image;
        Pixmap bitmap;
        uint8 *tdata;
        int bitmap_pad;

        if (g_server_bpp == 8)
        {
                bitmap_pad = 8;
        }
        else
        {
                bitmap_pad = g_bpp;

                if (g_bpp == 24)
                        bitmap_pad = 32;
        }

        tdata = (g_owncolmap ? data : translate_image(width, height, data));
        bitmap = XCreatePixmap(g_display, g_wnd, width, height, g_depth);
        image = XCreateImage(g_display, g_visual, g_depth, ZPixmap, 0,
                             (char *) tdata, width, height, bitmap_pad, 0);

        XPutImage(g_display, bitmap, g_create_bitmap_gc, image, 0, 0, 0, 0, width, height);

        XFree(image);
        if (tdata != data)
                xfree(tdata);
        return (HBITMAP) bitmap;
}

void
ui_paint_bitmap(int x, int y, int cx, int cy, int width, int height, uint8 * data)
{
        XImage *image;
        uint8 *tdata;
        int bitmap_pad;

        if (g_server_bpp == 8)
        {
                bitmap_pad = 8;
        }
        else
        {
                bitmap_pad = g_bpp;

                if (g_bpp == 24)
                        bitmap_pad = 32;
        }

        tdata = (g_owncolmap ? data : translate_image(width, height, data));
        image = XCreateImage(g_display, g_visual, g_depth, ZPixmap, 0,
                             (char *) tdata, width, height, bitmap_pad, 0);

        if (g_ownbackstore)
        {
                XPutImage(g_display, g_backstore, g_gc, image, 0, 0, x, y, cx, cy);
                XCopyArea(g_display, g_backstore, g_wnd, g_gc, x, y, cx, cy, x, y);
        }
        else
        {
                XPutImage(g_display, g_wnd, g_gc, image, 0, 0, x, y, cx, cy);
        }

        XFree(image);
        if (tdata != data)
                xfree(tdata);
}

void
ui_destroy_bitmap(HBITMAP bmp)
{
        XFreePixmap(g_display, (Pixmap) bmp);
}

HGLYPH
ui_create_glyph(int width, int height, uint8 * data)
{
        XImage *image;
        Pixmap bitmap;
        int scanline;

        scanline = (width + 7) / 8;

        bitmap = XCreatePixmap(g_display, g_wnd, width, height, 1);
        if (g_create_glyph_gc == 0)
                g_create_glyph_gc = XCreateGC(g_display, bitmap, 0, NULL);

        image = XCreateImage(g_display, g_visual, 1, ZPixmap, 0, (char *) data,
                             width, height, 8, scanline);
        image->byte_order = MSBFirst;
        image->bitmap_bit_order = MSBFirst;
        XInitImage(image);

        XPutImage(g_display, bitmap, g_create_glyph_gc, image, 0, 0, 0, 0, width, height);

        XFree(image);
        return (HGLYPH) bitmap;
}

void
ui_destroy_glyph(HGLYPH glyph)
{
        XFreePixmap(g_display, (Pixmap) glyph);
}

HCURSOR
ui_create_cursor(unsigned int x, unsigned int y, int width, int height,
                 uint8 * andmask, uint8 * xormask)
{
        HGLYPH maskglyph, cursorglyph;
        XColor bg, fg;
        Cursor xcursor;
        uint8 *cursor, *pcursor;
        uint8 *mask, *pmask;
        uint8 nextbit;
        int scanline, offset;
        int i, j;

        scanline = (width + 7) / 8;
        offset = scanline * height;

        cursor = (uint8 *) xmalloc(offset);
        memset(cursor, 0, offset);

        mask = (uint8 *) xmalloc(offset);
        memset(mask, 0, offset);

        /* approximate AND and XOR masks with a monochrome X pointer */
        for (i = 0; i < height; i++)
        {
                offset -= scanline;
                pcursor = &cursor[offset];
                pmask = &mask[offset];

                for (j = 0; j < scanline; j++)
                {
                        for (nextbit = 0x80; nextbit != 0; nextbit >>= 1)
                        {
                                if (xormask[0] || xormask[1] || xormask[2])
                                {
                                        *pcursor |= (~(*andmask) & nextbit);
                                        *pmask |= nextbit;
                                }
                                else
                                {
                                        *pcursor |= ((*andmask) & nextbit);
                                        *pmask |= (~(*andmask) & nextbit);
                                }

                                xormask += 3;
                        }

                        andmask++;
                        pcursor++;
                        pmask++;
                }
        }

        fg.red = fg.blue = fg.green = 0xffff;
        bg.red = bg.blue = bg.green = 0x0000;
        fg.flags = bg.flags = DoRed | DoBlue | DoGreen;

        cursorglyph = ui_create_glyph(width, height, cursor);
        maskglyph = ui_create_glyph(width, height, mask);

        xcursor =
                XCreatePixmapCursor(g_display, (Pixmap) cursorglyph,
                                    (Pixmap) maskglyph, &fg, &bg, x, y);

        ui_destroy_glyph(maskglyph);
        ui_destroy_glyph(cursorglyph);
        xfree(mask);
        xfree(cursor);
        return (HCURSOR) xcursor;
}

void
ui_set_cursor(HCURSOR cursor)
{
        g_current_cursor = (Cursor) cursor;
        XDefineCursor(g_display, g_wnd, g_current_cursor);
}

void
ui_destroy_cursor(HCURSOR cursor)
{
        XFreeCursor(g_display, (Cursor) cursor);
}

void
ui_set_null_cursor(void)
{
        ui_set_cursor(g_null_cursor);
}

#define MAKE_XCOLOR(xc,c) \
                (xc)->red   = ((c)->red   << 8) | (c)->red; \
                (xc)->green = ((c)->green << 8) | (c)->green; \
                (xc)->blue  = ((c)->blue  << 8) | (c)->blue; \
                (xc)->flags = DoRed | DoGreen | DoBlue;


HCOLOURMAP
ui_create_colourmap(COLOURMAP * colours)
{
        COLOURENTRY *entry;
        int i, ncolours = colours->ncolours;
        if (!g_owncolmap)
        {
                uint32 *map = (uint32 *) xmalloc(sizeof(*g_colmap) * ncolours);
                XColor xentry;
                XColor xc_cache[256];
                uint32 colour;
                int colLookup = 256;
                for (i = 0; i < ncolours; i++)
                {
                        entry = &colours->colours[i];
                        MAKE_XCOLOR(&xentry, entry);

                        if (XAllocColor(g_display, g_xcolmap, &xentry) == 0)
                        {
                                /* Allocation failed, find closest match. */
                                int j = 256;
                                int nMinDist = 3 * 256 * 256;
                                long nDist = nMinDist;

                                /* only get the colors once */
                                while (colLookup--)
                                {
                                        xc_cache[colLookup].pixel = colLookup;
                                        xc_cache[colLookup].red = xc_cache[colLookup].green =
                                                xc_cache[colLookup].blue = 0;
                                        xc_cache[colLookup].flags = 0;
                                        XQueryColor(g_display,
                                                    DefaultColormap(g_display,
                                                                    DefaultScreen(g_display)),
                                                    &xc_cache[colLookup]);
                                }
                                colLookup = 0;

                                /* approximate the pixel */
                                while (j--)
                                {
                                        if (xc_cache[j].flags)
                                        {
                                                nDist = ((long) (xc_cache[j].red >> 8) -
                                                         (long) (xentry.red >> 8)) *
                                                        ((long) (xc_cache[j].red >> 8) -
                                                         (long) (xentry.red >> 8)) +
                                                        ((long) (xc_cache[j].green >> 8) -
                                                         (long) (xentry.green >> 8)) *
                                                        ((long) (xc_cache[j].green >> 8) -
                                                         (long) (xentry.green >> 8)) +
                                                        ((long) (xc_cache[j].blue >> 8) -
                                                         (long) (xentry.blue >> 8)) *
                                                        ((long) (xc_cache[j].blue >> 8) -
                                                         (long) (xentry.blue >> 8));
                                        }
                                        if (nDist < nMinDist)
                                        {
                                                nMinDist = nDist;
                                                xentry.pixel = j;
                                        }
                                }
                        }
                        colour = xentry.pixel;

                        /* update our cache */
                        if (xentry.pixel < 256)
                        {
                                xc_cache[xentry.pixel].red = xentry.red;
                                xc_cache[xentry.pixel].green = xentry.green;
                                xc_cache[xentry.pixel].blue = xentry.blue;

                        }

                        map[i] = colour;
                }
                return map;
        }
        else
        {
                XColor *xcolours, *xentry;
                Colormap map;

                xcolours = (XColor *) xmalloc(sizeof(XColor) * ncolours);
                for (i = 0; i < ncolours; i++)
                {
                        entry = &colours->colours[i];
                        xentry = &xcolours[i];
                        xentry->pixel = i;
                        MAKE_XCOLOR(xentry, entry);
                }

                map = XCreateColormap(g_display, g_wnd, g_visual, AllocAll);
                XStoreColors(g_display, map, xcolours, ncolours);

                xfree(xcolours);
                return (HCOLOURMAP) map;
        }
}

void
ui_destroy_colourmap(HCOLOURMAP map)
{
        if (!g_owncolmap)
                xfree(map);
        else
                XFreeColormap(g_display, (Colormap) map);
}

void
ui_set_colourmap(HCOLOURMAP map)
{
        if (!g_owncolmap)
        {
                if (g_colmap)
                        xfree(g_colmap);

                g_colmap = (uint32 *) map;
        }
        else
                XSetWindowColormap(g_display, g_wnd, (Colormap) map);
}

void
ui_set_clip(int x, int y, int cx, int cy)
{
        XRectangle rect;

        rect.x = x;
        rect.y = y;
        rect.width = cx;
        rect.height = cy;
        XSetClipRectangles(g_display, g_gc, 0, 0, &rect, 1, YXBanded);
}

void
ui_reset_clip(void)
{
        XRectangle rect;

        rect.x = 0;
        rect.y = 0;
        rect.width = g_width;
        rect.height = g_height;
        XSetClipRectangles(g_display, g_gc, 0, 0, &rect, 1, YXBanded);
}

void
ui_bell(void)
{
        XBell(g_display, 0);
}

void
ui_destblt(uint8 opcode,
           /* dest */ int x, int y, int cx, int cy)
{
        SET_FUNCTION(opcode);
        FILL_RECTANGLE(x, y, cx, cy);
        RESET_FUNCTION(opcode);
}

static uint8 hatch_patterns[] = {
        0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, /* 0 - bsHorizontal */
        0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, /* 1 - bsVertical */
        0x80, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x01, /* 2 - bsFDiagonal */
        0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, /* 3 - bsBDiagonal */
        0x08, 0x08, 0x08, 0xff, 0x08, 0x08, 0x08, 0x08, /* 4 - bsCross */
        0x81, 0x42, 0x24, 0x18, 0x18, 0x24, 0x42, 0x81  /* 5 - bsDiagCross */
};

void
ui_patblt(uint8 opcode,
          /* dest */ int x, int y, int cx, int cy,
          /* brush */ BRUSH * brush, int bgcolour, int fgcolour)
{
        Pixmap fill;
        uint8 i, ipattern[8];

        SET_FUNCTION(opcode);

        switch (brush->style)
        {
                case 0: /* Solid */
                        SET_FOREGROUND(fgcolour);
                        FILL_RECTANGLE_BACKSTORE(x, y, cx, cy);
                        break;

                case 2: /* Hatch */
                        fill = (Pixmap) ui_create_glyph(8, 8,
                                                        hatch_patterns + brush->pattern[0] * 8);
                        SET_FOREGROUND(fgcolour);
                        SET_BACKGROUND(bgcolour);
                        XSetFillStyle(g_display, g_gc, FillOpaqueStippled);
                        XSetStipple(g_display, g_gc, fill);
                        XSetTSOrigin(g_display, g_gc, brush->xorigin, brush->yorigin);
                        FILL_RECTANGLE_BACKSTORE(x, y, cx, cy);
                        XSetFillStyle(g_display, g_gc, FillSolid);
                        XSetTSOrigin(g_display, g_gc, 0, 0);
                        ui_destroy_glyph((HGLYPH) fill);
                        break;

                case 3: /* Pattern */
                        for (i = 0; i != 8; i++)
                                ipattern[7 - i] = brush->pattern[i];
                        fill = (Pixmap) ui_create_glyph(8, 8, ipattern);
                        SET_FOREGROUND(bgcolour);
                        SET_BACKGROUND(fgcolour);
                        XSetFillStyle(g_display, g_gc, FillOpaqueStippled);
                        XSetStipple(g_display, g_gc, fill);
                        XSetTSOrigin(g_display, g_gc, brush->xorigin, brush->yorigin);
                        FILL_RECTANGLE_BACKSTORE(x, y, cx, cy);
                        XSetFillStyle(g_display, g_gc, FillSolid);
                        XSetTSOrigin(g_display, g_gc, 0, 0);
                        ui_destroy_glyph((HGLYPH) fill);
                        break;

                default:
                        unimpl("brush %d\n", brush->style);
        }

        RESET_FUNCTION(opcode);

        if (g_ownbackstore)
                XCopyArea(g_display, g_backstore, g_wnd, g_gc, x, y, cx, cy, x, y);
}

void
ui_screenblt(uint8 opcode,
             /* dest */ int x, int y, int cx, int cy,
             /* src */ int srcx, int srcy)
{
        SET_FUNCTION(opcode);
        if (g_ownbackstore)
        {
                if (g_Unobscured)
                {
                        XCopyArea(g_display, g_wnd, g_wnd, g_gc, srcx, srcy, cx, cy, x, y);
                        XCopyArea(g_display, g_backstore, g_backstore, g_gc, srcx, srcy, cx, cy, x,
                                  y);
                }
                else
                {
                        XCopyArea(g_display, g_backstore, g_wnd, g_gc, srcx, srcy, cx, cy, x, y);
                        XCopyArea(g_display, g_backstore, g_backstore, g_gc, srcx, srcy, cx, cy, x,
                                  y);
                }
        }
        else
        {
                XCopyArea(g_display, g_wnd, g_wnd, g_gc, srcx, srcy, cx, cy, x, y);
        }
        RESET_FUNCTION(opcode);
}

void
ui_memblt(uint8 opcode,
          /* dest */ int x, int y, int cx, int cy,
          /* src */ HBITMAP src, int srcx, int srcy)
{
        SET_FUNCTION(opcode);
        XCopyArea(g_display, (Pixmap) src, g_wnd, g_gc, srcx, srcy, cx, cy, x, y);
        if (g_ownbackstore)
                XCopyArea(g_display, (Pixmap) src, g_backstore, g_gc, srcx, srcy, cx, cy, x, y);
        RESET_FUNCTION(opcode);
}

void
ui_triblt(uint8 opcode,
          /* dest */ int x, int y, int cx, int cy,
          /* src */ HBITMAP src, int srcx, int srcy,
          /* brush */ BRUSH * brush, int bgcolour, int fgcolour)
{
        /* This is potentially difficult to do in general. Until someone
           comes up with a more efficient way of doing it I am using cases. */

        switch (opcode)
        {
                case 0x69:      /* PDSxxn */
                        ui_memblt(ROP2_XOR, x, y, cx, cy, src, srcx, srcy);
                        ui_patblt(ROP2_NXOR, x, y, cx, cy, brush, bgcolour, fgcolour);
                        break;

                case 0xb8:      /* PSDPxax */
                        ui_patblt(ROP2_XOR, x, y, cx, cy, brush, bgcolour, fgcolour);
                        ui_memblt(ROP2_AND, x, y, cx, cy, src, srcx, srcy);
                        ui_patblt(ROP2_XOR, x, y, cx, cy, brush, bgcolour, fgcolour);
                        break;

                case 0xc0:      /* PSa */
                        ui_memblt(ROP2_COPY, x, y, cx, cy, src, srcx, srcy);
                        ui_patblt(ROP2_AND, x, y, cx, cy, brush, bgcolour, fgcolour);
                        break;

                default:
                        unimpl("triblt 0x%x\n", opcode);
                        ui_memblt(ROP2_COPY, x, y, cx, cy, src, srcx, srcy);
        }
}

void
ui_line(uint8 opcode,
        /* dest */ int startx, int starty, int endx, int endy,
        /* pen */ PEN * pen)
{
        SET_FUNCTION(opcode);
        SET_FOREGROUND(pen->colour);
        XDrawLine(g_display, g_wnd, g_gc, startx, starty, endx, endy);
        if (g_ownbackstore)
                XDrawLine(g_display, g_backstore, g_gc, startx, starty, endx, endy);
        RESET_FUNCTION(opcode);
}

void
ui_rect(
               /* dest */ int x, int y, int cx, int cy,
               /* brush */ int colour)
{
        SET_FOREGROUND(colour);
        FILL_RECTANGLE(x, y, cx, cy);
}

void
ui_polygon(uint8 opcode,
           /* mode */ uint8 fillmode,
           /* dest */ POINT * point, int npoints,
           /* brush */ BRUSH * brush, int bgcolour, int fgcolour)
{
        uint8 style, i, ipattern[8];
        Pixmap fill;

        SET_FUNCTION(opcode);

        switch (fillmode)
        {
                case ALTERNATE:
                        XSetFillRule(g_display, g_gc, EvenOddRule);
                        break;
                case WINDING:
                        XSetFillRule(g_display, g_gc, WindingRule);
                        break;
                default:
                        unimpl("fill mode %d\n", fillmode);
        }

        if (brush)
                style = brush->style;
        else
                style = 0;

        switch (style)
        {
                case 0: /* Solid */
                        SET_FOREGROUND(fgcolour);
                        FILL_POLYGON((XPoint *) point, npoints);
                        break;

                case 2: /* Hatch */
                        fill = (Pixmap) ui_create_glyph(8, 8,
                                                        hatch_patterns + brush->pattern[0] * 8);
                        SET_FOREGROUND(fgcolour);
                        SET_BACKGROUND(bgcolour);
                        XSetFillStyle(g_display, g_gc, FillOpaqueStippled);
                        XSetStipple(g_display, g_gc, fill);
                        XSetTSOrigin(g_display, g_gc, brush->xorigin, brush->yorigin);
                        FILL_POLYGON((XPoint *) point, npoints);
                        XSetFillStyle(g_display, g_gc, FillSolid);
                        XSetTSOrigin(g_display, g_gc, 0, 0);
                        ui_destroy_glyph((HGLYPH) fill);
                        break;

                case 3: /* Pattern */
                        for (i = 0; i != 8; i++)
                                ipattern[7 - i] = brush->pattern[i];
                        fill = (Pixmap) ui_create_glyph(8, 8, ipattern);
                        SET_FOREGROUND(bgcolour);
                        SET_BACKGROUND(fgcolour);
                        XSetFillStyle(g_display, g_gc, FillOpaqueStippled);
                        XSetStipple(g_display, g_gc, fill);
                        XSetTSOrigin(g_display, g_gc, brush->xorigin, brush->yorigin);
                        FILL_POLYGON((XPoint *) point, npoints);
                        XSetFillStyle(g_display, g_gc, FillSolid);
                        XSetTSOrigin(g_display, g_gc, 0, 0);
                        ui_destroy_glyph((HGLYPH) fill);
                        break;

                default:
                        unimpl("brush %d\n", brush->style);
        }

        RESET_FUNCTION(opcode);
}

void
ui_polyline(uint8 opcode,
            /* dest */ POINT * points, int npoints,
            /* pen */ PEN * pen)
{
        /* TODO: set join style */
        SET_FUNCTION(opcode);
        SET_FOREGROUND(pen->colour);
        XDrawLines(g_display, g_wnd, g_gc, (XPoint *) points, npoints, CoordModePrevious);
        if (g_ownbackstore)
                XDrawLines(g_display, g_backstore, g_gc, (XPoint *) points, npoints,
                           CoordModePrevious);
        RESET_FUNCTION(opcode);
}

void
ui_ellipse(uint8 opcode,
           /* mode */ uint8 fillmode,
           /* dest */ int x, int y, int cx, int cy,
           /* brush */ BRUSH * brush, int bgcolour, int fgcolour)
{
        uint8 style, i, ipattern[8];
        Pixmap fill;

        SET_FUNCTION(opcode);

        if (brush)
                style = brush->style;
        else
                style = 0;

        switch (style)
        {
                case 0: /* Solid */
                        SET_FOREGROUND(fgcolour);
                        DRAW_ELLIPSE(x, y, cx, cy, fillmode);
                        break;

                case 2: /* Hatch */
                        fill = (Pixmap) ui_create_glyph(8, 8,
                                                        hatch_patterns + brush->pattern[0] * 8);
                        SET_FOREGROUND(fgcolour);
                        SET_BACKGROUND(bgcolour);
                        XSetFillStyle(g_display, g_gc, FillOpaqueStippled);
                        XSetStipple(g_display, g_gc, fill);
                        XSetTSOrigin(g_display, g_gc, brush->xorigin, brush->yorigin);
                        DRAW_ELLIPSE(x, y, cx, cy, fillmode);
                        XSetFillStyle(g_display, g_gc, FillSolid);
                        XSetTSOrigin(g_display, g_gc, 0, 0);
                        ui_destroy_glyph((HGLYPH) fill);
                        break;

                case 3: /* Pattern */
                        for (i = 0; i != 8; i++)
                                ipattern[7 - i] = brush->pattern[i];
                        fill = (Pixmap) ui_create_glyph(8, 8, ipattern);
                        SET_FOREGROUND(bgcolour);
                        SET_BACKGROUND(fgcolour);
                        XSetFillStyle(g_display, g_gc, FillOpaqueStippled);
                        XSetStipple(g_display, g_gc, fill);
                        XSetTSOrigin(g_display, g_gc, brush->xorigin, brush->yorigin);
                        DRAW_ELLIPSE(x, y, cx, cy, fillmode);
                        XSetFillStyle(g_display, g_gc, FillSolid);
                        XSetTSOrigin(g_display, g_gc, 0, 0);
                        ui_destroy_glyph((HGLYPH) fill);
                        break;

                default:
                        unimpl("brush %d\n", brush->style);
        }

        RESET_FUNCTION(opcode);
}

/* warning, this function only draws on wnd or backstore, not both */
void
ui_draw_glyph(int mixmode,
              /* dest */ int x, int y, int cx, int cy,
              /* src */ HGLYPH glyph, int srcx, int srcy,
              int bgcolour, int fgcolour)
{
        SET_FOREGROUND(fgcolour);
        SET_BACKGROUND(bgcolour);

        XSetFillStyle(g_display, g_gc,
                      (mixmode == MIX_TRANSPARENT) ? FillStippled : FillOpaqueStippled);
        XSetStipple(g_display, g_gc, (Pixmap) glyph);
        XSetTSOrigin(g_display, g_gc, x, y);

        FILL_RECTANGLE_BACKSTORE(x, y, cx, cy);

        XSetFillStyle(g_display, g_gc, FillSolid);
}

#define DO_GLYPH(ttext,idx) \
{\
  glyph = cache_get_font (font, ttext[idx]);\
  if (!(flags & TEXT2_IMPLICIT_X))\
  {\
    xyoffset = ttext[++idx];\
    if ((xyoffset & 0x80))\
    {\
      if (flags & TEXT2_VERTICAL)\
        y += ttext[idx+1] | (ttext[idx+2] << 8);\
      else\
        x += ttext[idx+1] | (ttext[idx+2] << 8);\
      idx += 2;\
    }\
    else\
    {\
      if (flags & TEXT2_VERTICAL)\
        y += xyoffset;\
      else\
        x += xyoffset;\
    }\
  }\
  if (glyph != NULL)\
  {\
    x1 = x + glyph->offset;\
    y1 = y + glyph->baseline;\
    XSetStipple(g_display, g_gc, (Pixmap) glyph->pixmap);\
    XSetTSOrigin(g_display, g_gc, x1, y1);\
    FILL_RECTANGLE_BACKSTORE(x1, y1, glyph->width, glyph->height);\
    if (flags & TEXT2_IMPLICIT_X)\
      x += glyph->width;\
  }\
}

void
ui_draw_text(uint8 font, uint8 flags, uint8 opcode, int mixmode, int x, int y,
             int clipx, int clipy, int clipcx, int clipcy,
             int boxx, int boxy, int boxcx, int boxcy, BRUSH * brush,
             int bgcolour, int fgcolour, uint8 * text, uint8 length)
{
        /* TODO: use brush appropriately */

        FONTGLYPH *glyph;
        int i, j, xyoffset, x1, y1;
        DATABLOB *entry;

        SET_FOREGROUND(bgcolour);

        /* Sometimes, the boxcx value is something really large, like
           32691. This makes XCopyArea fail with Xvnc. The code below
           is a quick fix. */
        if (boxx + boxcx > g_width)
                boxcx = g_width - boxx;

        if (boxcx > 1)
        {
                FILL_RECTANGLE_BACKSTORE(boxx, boxy, boxcx, boxcy);
        }
        else if (mixmode == MIX_OPAQUE)
        {
                FILL_RECTANGLE_BACKSTORE(clipx, clipy, clipcx, clipcy);
        }

        SET_FOREGROUND(fgcolour);
        SET_BACKGROUND(bgcolour);
        XSetFillStyle(g_display, g_gc, FillStippled);

        /* Paint text, character by character */
        for (i = 0; i < length;)
        {
                switch (text[i])
                {
                        case 0xff:
                                /* At least two bytes needs to follow */
                                if (i + 3 > length)
                                {
                                        warning("Skipping short 0xff command:");
                                        for (j = 0; j < length; j++)
                                                fprintf(stderr, "%02x ", text[j]);
                                        fprintf(stderr, "\n");
                                        i = length = 0;
                                        break;
                                }
                                cache_put_text(text[i + 1], text, text[i + 2]);
                                i += 3;
                                length -= i;
                                /* this will move pointer from start to first character after FF command */
                                text = &(text[i]);
                                i = 0;
                                break;

                        case 0xfe:
                                /* At least one byte needs to follow */
                                if (i + 2 > length)
                                {
                                        warning("Skipping short 0xfe command:");
                                        for (j = 0; j < length; j++)
                                                fprintf(stderr, "%02x ", text[j]);
                                        fprintf(stderr, "\n");
                                        i = length = 0;
                                        break;
                                }
                                entry = cache_get_text(text[i + 1]);
                                if (entry->data != NULL)
                                {
                                        if ((((uint8 *) (entry->data))[1] == 0)
                                            && (!(flags & TEXT2_IMPLICIT_X)) && (i + 2 < length))
                                        {
                                                if (flags & TEXT2_VERTICAL)
                                                        y += text[i + 2];
                                                else
                                                        x += text[i + 2];
                                        }
                                        for (j = 0; j < entry->size; j++)
                                                DO_GLYPH(((uint8 *) (entry->data)), j);
                                }
                                if (i + 2 < length)
                                        i += 3;
                                else
                                        i += 2;
                                length -= i;
                                /* this will move pointer from start to first character after FE command */
                                text = &(text[i]);
                                i = 0;
                                break;

                        default:
                                DO_GLYPH(text, i);
                                i++;
                                break;
                }
        }

        XSetFillStyle(g_display, g_gc, FillSolid);

        if (g_ownbackstore)
        {
                if (boxcx > 1)
                        XCopyArea(g_display, g_backstore, g_wnd, g_gc, boxx,
                                  boxy, boxcx, boxcy, boxx, boxy);
                else
                        XCopyArea(g_display, g_backstore, g_wnd, g_gc, clipx,
                                  clipy, clipcx, clipcy, clipx, clipy);
        }
}

void
ui_desktop_save(uint32 offset, int x, int y, int cx, int cy)
{
        Pixmap pix;
        XImage *image;

        if (g_ownbackstore)
        {
                image = XGetImage(g_display, g_backstore, x, y, cx, cy, AllPlanes, ZPixmap);
        }
        else
        {
                pix = XCreatePixmap(g_display, g_wnd, cx, cy, g_depth);
                XCopyArea(g_display, g_wnd, pix, g_gc, x, y, cx, cy, 0, 0);
                image = XGetImage(g_display, pix, 0, 0, cx, cy, AllPlanes, ZPixmap);
                XFreePixmap(g_display, pix);
        }

        offset *= g_bpp / 8;
        cache_put_desktop(offset, cx, cy, image->bytes_per_line, g_bpp / 8, (uint8 *) image->data);

        XDestroyImage(image);
}

void
ui_desktop_restore(uint32 offset, int x, int y, int cx, int cy)
{
        XImage *image;
        uint8 *data;

        offset *= g_bpp / 8;
        data = cache_get_desktop(offset, cx, cy, g_bpp / 8);
        if (data == NULL)
                return;

        image = XCreateImage(g_display, g_visual, g_depth, ZPixmap, 0,
                             (char *) data, cx, cy, BitmapPad(g_display), cx * g_bpp / 8);

        if (g_ownbackstore)
        {
                XPutImage(g_display, g_backstore, g_gc, image, 0, 0, x, y, cx, cy);
                XCopyArea(g_display, g_backstore, g_wnd, g_gc, x, y, cx, cy, x, y);
        }
        else
        {
                XPutImage(g_display, g_wnd, g_gc, image, 0, 0, x, y, cx, cy);
        }

        XFree(image);
}

/* these do nothing here but are used in uiports */
void
ui_begin_update(void)
{
}

void
ui_end_update(void)
{
}