/*
 * Copyright 1993-2001 by Xi Graphics, Inc.
 * All Rights Reserved.
 *
 * Please see the LICENSE file accompanying this distribution for licensing 
 * information. 
 *
 * Please send any bug fixes and modifications to src@xig.com.
 *
 * $XiGId: xme.c,v 1.2 2001/11/30 21:56:59 jon Exp $
 *
 */

#define NEED_EVENTS
#define NEED_REPLIES

#include <X11/Xlibint.h>
#include <X11/Xthreads.h>
#include <X11/Xmd.h>
#include <X11/Xproto.h>
#include "../extensions/Xext.h"
#include "../extensions/extutil.h"

/*****************************************************************************/


#define	XIGMISC_PROTOCOL_NAME 		     "XiG-SUNDRY-NONSTANDARD"
#define XIGMISC_MAJOR_VERSION	             2
#define XIGMISC_MINOR_VERSION 	             0

#define XiGMiscNumberEvents	             0

#define	X_XiGMiscQueryVersion		     0
#define	X_XiGMiscQueryViews		     1
#define X_XiGMiscQueryResolutions            2
#define X_XiGMiscChangeResolution            3
#define X_XiGMiscFullScreen                  4

#define sz_xXiGMiscQueryVersionReq	     8
#define sz_xXiGMiscQueryViewsReq	     8
#define sz_xXiGMiscQueryResolutionsReq       8
#define sz_xXiGMiscChangeResolutionReq       16
#define sz_xXiGMiscFullScreenReq             16

#define sz_xXiGMiscQueryVersionReply	     32
#define sz_xXiGMiscQueryViewsReply	     32
#define sz_xXiGMiscQueryResolutionsReply     32
#define sz_xXiGMiscQueryFullScreenReply      32

/*******************************************************************/

typedef struct
{
    CARD8 reqType;              /* always codes->major_opcode        */
    CARD8 xigmiscReqType;       /* always X_XiGMiscQueryVersion      */
    CARD16 length;
    CARD16 major;
    CARD16 minor;
} xXiGMiscQueryVersionReq;

typedef struct
{
    CARD8 reqType;              /* always codes->major_opcode        */
    CARD8 xigmiscReqType;       /* always X_XiGMiscQueryViews        */
    CARD16 length;
    CARD8 screen;
    CARD8 pad0;
    CARD16 pad1;
} xXiGMiscQueryViewsReq;

typedef struct
{
    CARD8 reqType;              /* always codes->major_opcode        */
    CARD8 xigmiscReqType;       /* always X_XiGMiscQueryResolutions  */
    CARD16 length;
    CARD8 screen;
    CARD8 view;
    CARD16 pad0;
} xXiGMiscQueryResolutionsReq;

typedef struct
{
    CARD8 reqType;              /* always codes->major_opcode        */
    CARD8 xigmiscReqType;       /* always X_XiGMiscChangeResolution  */
    CARD16 length;
    CARD8 screen;
    CARD8 view;
    CARD16 pad0;
    CARD16 width;
    CARD16 height;
    INT32 refresh;
} xXiGMiscChangeResolutionReq;

typedef struct
{
    CARD8 reqType;              /* always codes->major_opcode        */
    CARD8 xigmiscReqType;       /* always X_XiGMiscFullScreen        */
    CARD16 length;
    CARD8 screen;
    CARD8 pad0;
    CARD16 pad1;
    CARD32 window;
    CARD32 cmap;
} xXiGMiscFullScreenReq;

/*******************************************************************/

typedef struct
{
    BYTE type;                  /* X_Reply                           */
    CARD8 pad0;
    CARD16 sequenceNumber;
    CARD32 length;
    CARD16 major;
    CARD16 minor;
    CARD32 pad1;
    CARD32 pad2;
    CARD32 pad3;
    CARD32 pad4;
    CARD32 pad5;
} xXiGMiscQueryVersionReply;

typedef struct
{
    BYTE type;                  /* X_Reply                           */
    CARD8 pad0;
    CARD16 sequenceNumber;
    CARD32 length;
    CARD32 nviews;
    CARD32 pad1;
    CARD32 pad2;
    CARD32 pad3;
    CARD32 pad4;
    CARD32 pad5;
} xXiGMiscQueryViewsReply;

typedef struct
{
    BYTE type;                  /* X_Reply                           */
    CARD8 pad0;
    CARD16 sequenceNumber;
    CARD32 length;
    CARD16 active;
    CARD16 nresolutions;
    CARD32 pad1;
    CARD32 pad2;
    CARD32 pad3;
    CARD32 pad4;
    CARD32 pad5;
} xXiGMiscQueryResolutionsReply;

typedef struct
{
    BYTE type;                  /* X_Reply                           */
    BOOL success;
    CARD16 sequenceNumber;
    CARD32 length;
    CARD32 pad1;
    CARD32 pad2;
    CARD32 pad3;
    CARD32 pad4;
    CARD32 pad5;
    CARD32 pad6;
} xXiGMiscFullScreenReply;

/*******************************************************************/

typedef struct
{
    INT16 x;
    INT16 y;
    CARD16 w;
    CARD16 h;
} XiGMiscViewInfo;

typedef struct
{
    CARD16 width;
    CARD16 height;
    INT32 refresh;
} XiGMiscResolutionInfo;

/*****************************************************************************/

static XExtensionInfo *xigmisc_info = NULL;
static char *xigmisc_extension_name = XIGMISC_PROTOCOL_NAME;

#define XiGMiscCheckExtension(dpy,i,val) \
  XextCheckExtension (dpy, i, xigmisc_extension_name, val)
#define XiGMiscSimpleCheckExtension(dpy,i) \
  XextSimpleCheckExtension (dpy, i, xigmisc_extension_name)

#if defined(__STDC__) && !defined(UNIXCPP)
#define XiGMiscGetReq(name,req,info) GetReq (name, req); \
        req->reqType = info->codes->major_opcode; \
        req->xigmiscReqType = X_##name;

#define XiGMiscGetReqExtra(name,n,req,info) GetReqExtra (name, n, req); \
        req->reqType = info->codes->major_opcode; \
        req->xigmicReqType = X_##name;
#else
#define XiGMiscGetReq(name,req,info) GetReq (name, req); \
        req->reqType = info->codes->major_opcode; \
        req->xigmiscReqType = X_/**/name;
#define XiGMiscGetReqExtra(name,n,req,info) GetReqExtra (name, n, req); \
        req->reqType = info->codes->major_opcode; \
        req->xigmiscReqType = X_/**/name;
#endif



/*
 * find_display - locate the display info block
 */
static int XiGMiscCloseDisplay();

static XExtensionHooks xigmisc_extension_hooks = {
    NULL,                       /* create_gc */
    NULL,                       /* copy_gc */
    NULL,                       /* flush_gc */
    NULL,                       /* free_gc */
    NULL,                       /* create_font */
    NULL,                       /* free_font */
    XiGMiscCloseDisplay,        /* close_display */
    NULL,                       /* wire_to_event */
    NULL,                       /* event_to_wire */
    NULL,                       /* error */
    NULL,                       /* error_string */
};


static
XEXT_GENERATE_CLOSE_DISPLAY(XiGMiscCloseDisplay, xigmisc_info)
     static XEXT_GENERATE_FIND_DISPLAY(XiGMiscFindDisplay, xigmisc_info,
                                       xigmisc_extension_name,
                                       &xigmisc_extension_hooks,
                                       XiGMiscNumberEvents, NULL)
/*****************************************************************************/
     Bool XiGMiscQueryVersion(Display * dpy, int *major, int *minor)
{
    int opcode, event, error;
    xXiGMiscQueryVersionReq *req;
    xXiGMiscQueryVersionReply rep;
    XExtDisplayInfo *info = XiGMiscFindDisplay(dpy);

    if (!XQueryExtension(dpy, XIGMISC_PROTOCOL_NAME, &opcode, &event, &error))
        return xFalse;

    XiGMiscCheckExtension(dpy, info, xFalse);

    LockDisplay(dpy);
    XiGMiscGetReq(XiGMiscQueryVersion, req, info);

    req->major = XIGMISC_MAJOR_VERSION;
    req->minor = XIGMISC_MINOR_VERSION;

    if (!_XReply(dpy, (xReply *) & rep, 0, xTrue)) {
        UnlockDisplay(dpy);
        SyncHandle();
        return xFalse;
    }

    *major = rep.major;
    *minor = rep.minor;
    UnlockDisplay(dpy);
    SyncHandle();

    return xTrue;
}

int
XiGMiscQueryViews(Display * dpy, int screen, XiGMiscViewInfo ** pviews)
{
    int n, size;
    XiGMiscViewInfo *views;
    xXiGMiscQueryViewsReq *req;
    xXiGMiscQueryViewsReply rep;
    XExtDisplayInfo *info = XiGMiscFindDisplay(dpy);
    XiGMiscCheckExtension(dpy, info, 0);

    LockDisplay(dpy);
    XiGMiscGetReq(XiGMiscQueryViews, req, info);
    req->screen = screen;

    if (!_XReply(dpy, (xReply *) & rep, 0, xFalse)) {
        UnlockDisplay(dpy);
        SyncHandle();
        return 0;
    }

    n = rep.nviews;

    if (n > 0) {
        size = sizeof(XiGMiscViewInfo) * n;
        views = (XiGMiscViewInfo *) Xmalloc(size);
        if (!views) {
            _XEatData(dpy, (unsigned long) size);
            UnlockDisplay(dpy);
            SyncHandle();
            return 0;
        }

        _XReadPad(dpy, (void *) views, size);

        *pviews = views;
    }

    UnlockDisplay(dpy);
    SyncHandle();

    return n;
}

int
XiGMiscQueryResolutions(Display * dpy, int screen, int view, int *pactive,
                        XiGMiscResolutionInfo ** presolutions)
{
    int n, size;
    XiGMiscResolutionInfo *resolutions;
    xXiGMiscQueryResolutionsReq *req;
    xXiGMiscQueryResolutionsReply rep;
    XExtDisplayInfo *info = XiGMiscFindDisplay(dpy);
    XiGMiscCheckExtension(dpy, info, 0);

    LockDisplay(dpy);
    XiGMiscGetReq(XiGMiscQueryResolutions, req, info);
    req->screen = screen;
    req->view = view;

    if (!_XReply(dpy, (xReply *) & rep, 0, xFalse)) {
        UnlockDisplay(dpy);
        SyncHandle();
        return 0;
    }

    n = rep.nresolutions;

    if (n > 0) {
        size = sizeof(XiGMiscResolutionInfo) * n;
        resolutions = (XiGMiscResolutionInfo *) Xmalloc(size);
        if (!resolutions) {
            _XEatData(dpy, (unsigned long) size);
            UnlockDisplay(dpy);
            SyncHandle();
            return 0;
        }

        _XReadPad(dpy, (void *) resolutions, size);

        *presolutions = resolutions;
        *pactive = rep.active;
    }

    UnlockDisplay(dpy);
    SyncHandle();

    return n;
}

void
XiGMiscChangeResolution(Display * dpy, int screen, int view, int width,
                        int height, int refresh)
{
    xXiGMiscChangeResolutionReq *req;
    XExtDisplayInfo *info = XiGMiscFindDisplay(dpy);

    XiGMiscSimpleCheckExtension(dpy, info);

    LockDisplay(dpy);
    XiGMiscGetReq(XiGMiscChangeResolution, req, info);
    req->screen = screen;
    req->view = view;
    req->width = width;
    req->height = height;
    req->refresh = refresh;

    UnlockDisplay(dpy);
    SyncHandle();
}


Bool
XiGMiscFullScreen(Display * dpy, int screen, XID window, XID cmap)
{
    xXiGMiscFullScreenReq *req;
    xXiGMiscFullScreenReply rep;
    XExtDisplayInfo *info = XiGMiscFindDisplay(dpy);

    XiGMiscCheckExtension(dpy, info, xFalse);

    LockDisplay(dpy);
    XiGMiscGetReq(XiGMiscFullScreen, req, info);
    req->screen = screen;
    req->pad0 = 0;
    req->pad1 = 0;
    req->window = window;
    req->cmap = cmap;

    if (!_XReply(dpy, (xReply *) & rep, 0, xTrue)) {
        UnlockDisplay(dpy);
        SyncHandle();
        return xFalse;
    }

    UnlockDisplay(dpy);
    SyncHandle();

    return (rep.success ? xTrue : xFalse);
}

/* vi: set ts=4 sw=4 expandtab: */