/*

 * 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);

}

/* SDL addition from Ryan: free memory used by xme. */

void XiGMiscDestroy(void)

{

    if (xigmisc_info) {

        XextDestroyExtension(xigmisc_info);

        xigmisc_info = NULL;

    }

}