Subversion Repositories or1k_old

#ifndef _SERV_H

#define _SERV_H

/*

 * Copyright (c) 2000 Greg Haerr <greg@censoft.com>

 * Copyright (c) 2000 Alex Holden <alex@linuxhacker.org>

 * Copyright (c) 1991 David I. Bell

 * Permission is granted to use, distribute, or modify this source,

 * provided that this copyright notice remains intact.

 *

 * Private definitions for the graphics server.

 * These definitions are not to be used by clients.

 */

#if defined(__ECOS) && !defined(_NO_SVR_MAPPING)

//

// Since eCos is a single task, multi-threaded environment, the

// server and the client code share the same namespace.  This means

// that server functions which are represented by dispatchers in

// the client code need to have unique names, thus this remapping.

//

#define GrArcAngle              SVR_GrArcAngle

#define GrArc                   SVR_GrArc

#define GrArea                  SVR_GrArea

#define GrBell                  SVR_GrBell

#define GrBitmap                SVR_GrBitmap

#define GrCheckNextEvent        SVR_GrCheckNextEvent

#define GrClearWindow           SVR_GrClearWindow

#define GrClose                 SVR_GrClose

#define GrCloseWindow           SVR_GrCloseWindow

#define GrCopyArea              SVR_GrCopyArea

#define GrCopyGC                SVR_GrCopyGC

#define GrCreateFont            SVR_GrCreateFont

#define GrDestroyFont           SVR_GrDestroyFont

#define GrDestroyGC             SVR_GrDestroyGC

#define GrDestroyRegion         SVR_GrDestroyRegion

#define GrDestroyWindow         SVR_GrDestroyWindow

#define GrDrawImageBits         SVR_GrDrawImageBits

#define GrDrawImageFromFile     SVR_GrDrawImageFromFile

#define GrDrawImageToFit        SVR_GrDrawImageToFit

#define GrEllipse               SVR_GrEllipse

#define GrEmptyRegion           SVR_GrEmptyRegion

#define GrEqualRegion           SVR_GrEqualRegion

#define GrFillEllipse           SVR_GrFillEllipse

#define GrFillPoly              SVR_GrFillPoly

#define GrFillRect              SVR_GrFillRect

#define GrFindColor             SVR_GrFindColor

#define GrFreeImage             SVR_GrFreeImage

#define GrGetFocus              SVR_GrGetFocus

#define GrGetFontInfo           SVR_GrGetFontInfo

#define GrGetGCInfo             SVR_GrGetGCInfo

#define GrGetGCTextSize         SVR_GrGetGCTextSize

#define GrGetImageInfo          SVR_GrGetImageInfo

#define GrGetRegionBox          SVR_GrGetRegionBox

#define GrGetScreenInfo         SVR_GrGetScreenInfo

#define GrGetSelectionOwner     SVR_GrGetSelectionOwner

#define GrGetSysColor           SVR_GrGetSysColor

#define GrGetSystemPalette      SVR_GrGetSystemPalette

#define GrGetWindowInfo         SVR_GrGetWindowInfo

#define GrGetWMProperties       SVR_GrGetWMProperties

#define GrInjectKeyboardEvent   SVR_GrInjectKeyboardEvent

#define GrInjectPointerEvent    SVR_GrInjectPointerEvent

#define GrIntersectRegion       SVR_GrIntersectRegion

#define GrKillWindow            SVR_GrKillWindow

#define GrLine                  SVR_GrLine

#define GrLoadImageFromFile     SVR_GrLoadImageFromFile

#define GrLowerWindow           SVR_GrLowerWindow

#define GrMapWindow             SVR_GrMapWindow

#define GrMoveCursor            SVR_GrMoveCursor

#define GrMoveWindow            SVR_GrMoveWindow

#define GrNewGC                 SVR_GrNewGC

#define GrNewInputWindow        SVR_GrNewInputWindow

#define GrNewPixmap             SVR_GrNewPixmap

#define GrNewPolygonRegion      SVR_GrNewPolygonRegion

#define GrNewRegion             SVR_GrNewRegion

#define GrNewWindow             SVR_GrNewWindow

#define GrOffsetRegion          SVR_GrOffsetRegion

#define GrOpen                  SVR_GrOpen

#define GrPeekEvent             SVR_GrPeekEvent

#define GrPointInRegion         SVR_GrPointInRegion

#define GrPoints                SVR_GrPoints

#define GrPoint                 SVR_GrPoint

#define GrPoly                  SVR_GrPoly

#define GrRaiseWindow           SVR_GrRaiseWindow

#define GrReadArea              SVR_GrReadArea

#define GrRectInRegion          SVR_GrRectInRegion

#define GrRect                  SVR_GrRect

#define GrReparentWindow        SVR_GrReparentWindow

#define GrRequestClientData     SVR_GrRequestClientData

#define GrResizeWindow          SVR_GrResizeWindow

#define GrSelectEvents          SVR_GrSelectEvents

#define GrSendClientData        SVR_GrSendClientData

#define GrSetBackgroundPixmap   SVR_GrSetBackgroundPixmap

#define GrSetBorderColor        SVR_GrSetBorderColor

#define GrSetCursor             SVR_GrSetCursor

#define GrSetFocus              SVR_GrSetFocus

#define GrSetFontAttr           SVR_GrSetFontAttr

#define GrSetFontRotation       SVR_GrSetFontRotation

#define GrSetFontSize           SVR_GrSetFontSize

#define GrSetGCBackground       SVR_GrSetGCBackground

#define GrSetGCFont             SVR_GrSetGCFont

#define GrSetGCForeground       SVR_GrSetGCForeground

#define GrSetGCMode             SVR_GrSetGCMode

#define GrSetGCRegion           SVR_GrSetGCRegion

#define GrSetGCUseBackground    SVR_GrSetGCUseBackground

#define GrSetScreenSaverTimeout SVR_GrSetScreenSaverTimeout

#define GrSetSelectionOwner     SVR_GrSetSelectionOwner

#define GrSetSystemPalette      SVR_GrSetSystemPalette

#define GrSetWMProperties       SVR_GrSetWMProperties

#define GrSubtractRegion        SVR_GrSubtractRegion

#define GrText                  SVR_GrText

#define GrUnionRectWithRegion   SVR_GrUnionRectWithRegion

#define GrUnionRegion           SVR_GrUnionRegion

#define GrUnmapWindow           SVR_GrUnmapWindow

#define GrXorRegion             SVR_GrXorRegion

#endif

#include "nano-X.h"

#include "device.h"

/*

 * Drawing types.

 */

typedef int     GR_DRAW_TYPE;

#define GR_DRAW_TYPE_NONE       0        /* none or error */

#define GR_DRAW_TYPE_WINDOW     1       /* windows */

#define GR_DRAW_TYPE_PIXMAP     2       /* pixmaps */

#define GR_MAX_MODE             MWMODE_MAX

/*

 * List of elements for events.

 */

typedef struct gr_event_list GR_EVENT_LIST;

struct gr_event_list {

        GR_EVENT_LIST   *next;          /* next element in list */

        GR_EVENT        event;          /* event */

};

/*

 * Data structure to keep track of state of clients.

 */

typedef struct gr_client GR_CLIENT;

struct gr_client {

        int             id;             /* client id and socket descriptor */

        GR_EVENT_LIST   *eventhead;     /* head of event chain (or NULL) */

        GR_EVENT_LIST   *eventtail;     /* tail of event chain (or NULL) */

        GR_CLIENT       *next;          /* the next client in the list */

        GR_CLIENT       *prev;          /* the previous client in the list */

        int             waiting_for_event; /* used to implement GrGetNextEvent*/

        char            *shm_cmds;

        int             shm_cmds_size;

        int             shm_cmds_shmid;

        unsigned long   processid;      /* client process id*/

};

/*

 * Structure to remember clients associated with events.

 */

typedef struct gr_event_client  GR_EVENT_CLIENT;

struct gr_event_client  {

        GR_EVENT_CLIENT *next;          /* next interested client or NULL */

        GR_EVENT_MASK   eventmask;      /* events client wants to see */

        GR_CLIENT       *client;        /* client who is interested */

};

/*

 * Structure to remember graphics contexts.

 */

typedef struct gr_gc    GR_GC;

struct gr_gc {

        GR_GC_ID        id;             /* graphics context id */

        int             mode;           /* drawing mode */

        GR_REGION_ID    regionid;       /* current clipping region */

        int             xoff;           /* X offset for the clip region */

        int             yoff;           /* Y offset for the clip region */

        GR_FONT_ID      fontid;         /* current font id*/

        GR_COLOR        foreground;     /* foreground color */

        GR_COLOR        background;     /* background color */

        GR_BOOL         usebackground;  /* actually display the background */

        GR_BOOL         changed;        /* graphics context has been changed */

        GR_CLIENT       *owner;         /* client that created it */

        GR_GC           *next;          /* next graphics context */

};

/*

 * Structure to remember regions.

 */

typedef struct gr_region        GR_REGION;

struct gr_region {

        MWCLIPREGION *  rgn;

        GR_REGION_ID    id;

        GR_CLIENT *     owner;          /* client that created it */

        GR_REGION *     next;

};

/*

 * Structure to remember fonts.

 */

typedef struct gr_font  GR_FONT;

struct gr_font {

        PMWFONT         pfont;          /* font*/

        int             fontsize;       /* font size*/

        GR_FONT_ID      id;             /* font id*/

        GR_CLIENT *     owner;          /* client that created it */

        GR_FONT *       next;           /* next font*/

};

/*

 * Structure to remember images.

 */

typedef struct gr_image GR_IMAGE;

struct gr_image {

        GR_IMAGE_ID     id;

        GR_CLIENT *     owner;          /* client that created it */

        GR_IMAGE *      next;

};

/*

 * Cursor structure.

 */

typedef struct gr_cursor GR_CURSOR;

struct gr_cursor {

        GR_CURSOR_ID    id;             /* cursor id*/

        GR_CLIENT       *owner;         /* client that created it*/

        GR_CURSOR       *next;

        MWCURSOR        cursor;         /* mwin engine cursor structure*/

};

/*

 * Structure to remember selection owner and mime types it can produce.

 */

typedef struct {

        GR_WINDOW_ID wid;

        GR_CHAR *typelist;

} GR_SELECTIONOWNER;

/*

 * Structure to remember timers.

 */

typedef struct gr_timer GR_TIMER;

struct gr_timer

{

    GR_TIMER_ID    id;       /* This instances ID */

    GR_CLIENT     *owner;    /* client that created it */

    GR_WINDOW_ID   wid;

    MWTIMER       *timer;    /* Device independent layer timer */

    GR_TIMER      *next;

};

/*

 * Drawable structure.  This structure must be the first

 * elements in a GR_WINDOW or GR_PIXMAP, as GrPrepareWindow

 * returns a GR_DRAWABLE.  This structure includes

 * only those items that routines that use GrPrepareWindow

 * might dereference, and must be included in windows or pixmaps.

 */

typedef struct gr_drawable {

        GR_COORD        x;              /* x position (0)*/

        GR_COORD        y;              /* y position (0)*/

        GR_SIZE         width;          /* width */

        GR_SIZE         height;         /* height */

        struct _mwscreendevice *psd;    /* associated screen device */

        GR_WINDOW_ID    id;             /* window/pixmap id */

} GR_DRAWABLE;

/*

 * Window structure

 * Note: first elements must match GR_DRAWABLE

 */

typedef struct gr_pixmap GR_PIXMAP;

typedef struct gr_window GR_WINDOW;

struct gr_window {

        GR_COORD        x;              /* absolute x position */

        GR_COORD        y;              /* absolute y position */

        GR_SIZE         width;          /* width */

        GR_SIZE         height;         /* height */

        struct _mwscreendevice *psd;    /* associated screen device */

        GR_WINDOW_ID    id;             /* window id */

        /* end of GR_DRAWABLE common members*/

        GR_WINDOW       *next;          /* next window in complete list */

        GR_CLIENT       *owner;         /* client that created it */

        GR_WINDOW       *parent;        /* parent window */

        GR_WINDOW       *children;      /* first child window */

        GR_WINDOW       *siblings;      /* next sibling window */

        GR_SIZE         bordersize;     /* size of border */

        GR_COLOR        bordercolor;    /* color of border */

        GR_COLOR        background;     /* background color */

        GR_PIXMAP       *bgpixmap;      /* background pixmap */

        int             bgpixmapflags;  /* center, tile etc. */

        GR_EVENT_MASK   nopropmask;     /* events not to be propagated */

        GR_EVENT_CLIENT *eventclients;  /* clients interested in events */

        GR_CURSOR_ID    cursorid;       /* cursor for this window */

        GR_BOOL         mapped;         /* TRUE if explicitly mapped */

        GR_COUNT        unmapcount;     /* count of reasons not really mapped */

        GR_BOOL         output;         /* TRUE if window can do output */

        GR_WM_PROPS     props;          /* window properties*/

        GR_CHAR         *title;         /* window title*/

};

/*

 * Pixmap structure

 * Note: first elements must match GR_DRAWABLE

 */

struct gr_pixmap {

        GR_COORD        x;              /* x position (0)*/

        GR_COORD        y;              /* y position (0)*/

        GR_SIZE         width;          /* width */

        GR_SIZE         height;         /* height */

        struct _mwscreendevice *psd;    /* associated screen device */

        GR_WINDOW_ID    id;             /* pixmap id */

        /* end of GR_DRAWABLE common members*/

        GR_PIXMAP       *next;          /* next pixmap in list */

        GR_CLIENT       *owner;         /* client that created it */

};

/*

 * Macros to obtain the client number from a resource id, and to

 * produce the first resource id to be used for a client number.

 * Client numbers must not be zero.  This allows for 255 clients.

#define GR_ID_CLIENT(n) (((GR_ID) (n)) >> 24)

#define GR_ID_BASE(n)   (((GR_ID) (n)) << 24)

 */

/*

 * Graphics server routines.

 */

int             GsInitialize(void);

void            GsClose(int fd);

void            GsSelect(GR_TIMEOUT timeout);

void            GsTerminate(void);

GR_TIMEOUT      GsGetTickCount(void);

void            GsRedrawScreen(void);

void            GsError(GR_ERROR code, GR_ID id);

GR_BOOL         GsCheckMouseEvent(void);

GR_BOOL         GsCheckKeyboardEvent(void);

int             GsReadKeyboard(GR_CHAR *buf, int *modifiers);

int             GsOpenKeyboard(void);

void            GsGetButtonInfo(int *buttons);

void            GsGetModifierInfo(int *modifiers);

void            GsCloseKeyboard(void);

void            GsExposeArea(GR_WINDOW *wp, GR_COORD rootx, GR_COORD rooty,

                        GR_SIZE width, GR_SIZE height, GR_WINDOW *stopwp);

void            GsCheckCursor(void);

void            GsWpSetFocus(GR_WINDOW *wp);

void            GsWpDrawBackgroundPixmap(GR_WINDOW *wp, GR_PIXMAP *pm,

                        GR_COORD x, GR_COORD y, GR_SIZE width, GR_SIZE height);

void            GsWpTileBackgroundPixmap(GR_WINDOW *wp, GR_PIXMAP *pm,

                        GR_COORD x, GR_COORD y, GR_SIZE width, GR_SIZE height);

void            GsWpClearWindow(GR_WINDOW *wp, GR_COORD x, GR_COORD y,

                        GR_SIZE width, GR_SIZE height, GR_BOOL exposeflag);

void            GsWpUnmapWindow(GR_WINDOW *wp, GR_BOOL temp_unmap);

void            GsWpMapWindow(GR_WINDOW *wp, GR_BOOL temp);

void            GsWpDestroyWindow(GR_WINDOW *wp);

void            GsSetPortraitMode(int mode);

void            GsSetPortraitModeFromXY(GR_COORD rootx, GR_COORD rooty);

void            GsSetClipWindow(GR_WINDOW *wp, MWCLIPREGION *userregion,

                        int flags);

void            GsHandleMouseStatus(GR_COORD newx, GR_COORD newy,

                        int newbuttons);

void            GsFreePositionEvent(GR_CLIENT *client, GR_WINDOW_ID wid,

                        GR_WINDOW_ID subwid);

void            GsDeliverButtonEvent(GR_EVENT_TYPE type, int buttons,

                        int changebuttons, int modifiers);

void            GsDeliverMotionEvent(GR_EVENT_TYPE type, int buttons,

                        MWKEYMOD modifiers);

void            GsDeliverKeyboardEvent(GR_WINDOW_ID wid, GR_EVENT_TYPE type,

                        GR_KEY keyvalue, GR_KEYMOD modifiers,

                        GR_SCANCODE scancode);

void            GsDeliverExposureEvent(GR_WINDOW *wp, GR_COORD x, GR_COORD y,

                        GR_SIZE width, GR_SIZE height);

void            GsFreeExposureEvent(GR_CLIENT *client, GR_WINDOW_ID wid,

                        GR_COORD x, GR_COORD y, GR_SIZE width, GR_SIZE height);

void            GsDeliverUpdateEvent(GR_WINDOW *wp, GR_UPDATE_TYPE utype,

                        GR_COORD x, GR_COORD y, GR_SIZE width, GR_SIZE height);

void            GsDeliverGeneralEvent(GR_WINDOW *wp, GR_EVENT_TYPE type,

                        GR_WINDOW *other);

void            GsDeliverPortraitChangedEvent(void);

void            GsDeliverScreenSaverEvent(GR_BOOL activate);

void            GsDeliverClientDataReqEvent(GR_WINDOW_ID wid, GR_WINDOW_ID rid,

                        GR_SERIALNO serial, GR_MIMETYPE mimetype);

void            GsDeliverClientDataEvent(GR_WINDOW_ID wid, GR_WINDOW_ID rid,

                        GR_SERIALNO serial, GR_LENGTH len, GR_LENGTH thislen,

                        void *data);

void            GsDeliverSelectionChangedEvent(GR_WINDOW_ID old_owner,

                        GR_WINDOW_ID new_owner);

void            GsDeliverTimerEvent(GR_CLIENT *client, GR_WINDOW_ID wid,

                        GR_TIMER_ID tid);

void            GsCheckMouseWindow(void);

void            GsCheckFocusWindow(void);

GR_DRAW_TYPE    GsPrepareDrawing(GR_DRAW_ID id, GR_GC_ID gcid,

                        GR_DRAWABLE **retdp);

GR_BOOL         GsCheckOverlap(GR_WINDOW *topwp, GR_WINDOW *botwp);

GR_EVENT        *GsAllocEvent(GR_CLIENT *client);

GR_WINDOW       *GsFindWindow(GR_WINDOW_ID id);

GR_PIXMAP       *GsFindPixmap(GR_WINDOW_ID id);

GR_GC           *GsFindGC(GR_GC_ID gcid);

GR_REGION       *GsFindRegion(GR_REGION_ID regionid);

GR_FONT         *GsFindFont(GR_FONT_ID fontid);

GR_TIMER        *GsFindTimer(GR_TIMER_ID timer_id);

GR_CURSOR       *GsFindCursor(GR_CURSOR_ID cursorid);

GR_WINDOW       *GsPrepareWindow(GR_WINDOW_ID wid);

GR_WINDOW       *GsFindVisibleWindow(GR_COORD x, GR_COORD y);

void            GsDrawBorder(GR_WINDOW *wp);

int             GsCurrentVt(void);

void            GsRedrawVt(int t);

int             GsOpenSocket(void);

void            GsCloseSocket(void);

void            GsAcceptClient(void);

void            GsAcceptClientFd(int i);

int             GsPutCh(int fd, unsigned char c);

GR_CLIENT       *GsFindClient(int fd);

void            GsDestroyClientResources(GR_CLIENT * client);

void            GsDropClient(int fd);

int             GsRead(int fd, void *buf, int c);

int             GsWrite(int fd, void *buf, int c);

void            GsHandleClient(int fd);

void            GsResetScreenSaver(void);

void            GsActivateScreenSaver(void *arg);

void            GrGetNextEventWrapperFinish(int);

void            GsTimerCB(void *arg);

/*

 * External data definitions.

 */

extern  char *          curfunc;                /* current function name */

extern  GR_WINDOW_ID    cachewindowid;          /* cached window id */

extern  GR_WINDOW_ID    cachepixmapid;

extern  GR_GC_ID        cachegcid;              /* cached graphics context id */

extern  GR_GC           *cachegcp;              /* cached graphics context */

extern  GR_GC           *listgcp;               /* list of all gc */

extern  GR_REGION       *listregionp;           /* list of all regions */

extern  GR_FONT         *listfontp;             /* list of all fonts */

extern  GR_IMAGE        *listimagep;            /* list of all images */

extern  GR_CURSOR       *listcursorp;           /* list of all cursors */

extern  GR_CURSOR       *stdcursor;             /* root window cursor */

extern  GR_GC           *curgcp;                /* current graphics context */

extern  GR_WINDOW       *cachewp;               /* cached window pointer */

extern  GR_PIXMAP       *cachepp;               /* cached pixmap pointer */

extern  GR_WINDOW       *listwp;                /* list of all windows */

extern  GR_PIXMAP       *listpp;                /* list of all pixmaps */

extern  GR_WINDOW       *rootwp;                /* root window pointer */

extern  GR_WINDOW       *clipwp;                /* window clipping is set for */

extern  GR_WINDOW       *focuswp;               /* focus window for keyboard */

extern  GR_WINDOW       *mousewp;               /* window mouse is currently in */

extern  GR_WINDOW       *grabbuttonwp;          /* window grabbed by button */

extern  GR_CURSOR       *curcursor;             /* currently enabled cursor */

extern  GR_COORD        cursorx;                /* x position of cursor */

extern  GR_COORD        cursory;                /* y position of cursor */

extern  int             curbuttons;             /* current state of buttons */

extern  GR_CLIENT       *curclient;             /* current client */

extern  char            *current_shm_cmds;

extern  int             current_shm_cmds_size;

extern  GR_EVENT_LIST   *eventfree;             /* list of free events */

extern  GR_BOOL         focusfixed;             /* TRUE if focus is fixed */

extern  GR_SCREEN_INFO  sinfo;                  /* screen information */

extern  PMWFONT         stdfont;                /* default font*/

extern  int             escape_quits;           /* terminate when pressing ESC*/

extern  int             connectcount;           /* # of connections to server */

extern  GR_TIMEOUT      screensaver_delay;      /* time before screensaver */

                                                /* activates */

extern  GR_TIMER_ID     cache_timer_id;         /* cached timer ID */

extern  GR_TIMER        *cache_timer;           /* cached timer */

extern  GR_TIMER        *list_timer;            /* list of all timers */

extern  GR_BOOL         screensaver_active;     /* screensaver is active */

extern  GR_SELECTIONOWNER selection_owner;      /* the selection owner */

extern  int             autoportrait;           /* auto portrait mode switching*/

/*

 * The filename to use for the named socket. If we ever support multiple

 * servers on one machine, the last digit will be that of the FB used for it.

 */

#define GR_NAMED_SOCKET "/tmp/.nano-X"

#define GR_NUMB_SOCKET 79

#if VTSWITCH

/* temp framebuffer vt switch stuff at upper level

 * this should be handled at the lower level, just like vgalib does.

 */

void MwInitVt(void);

int  MwCurrentVt(void);

int  MwCheckVtChange(void);

void MwRedrawVt(int t);

void MwExitVt(void);

extern int mwvterm;

#endif /* VTSWITCH*/

#endif /* _SERV_H*/