#ifdef XCALIBRATE

extern void XCalibrateExtensionInit(INITARGS);

#endif

#ifdef  XCALIBRATE

    XCalibrateExtensionInit ();

#endif

AC_ARG_ENABLE(xcalibrate,     AS_HELP_STRING([--enable-xcalibrate], [Build XCalibrate extension (default: disabled)]), [XCALIBRATE=$enableval], [XCALIBRATE=no])

AM_CONDITIONAL(XCALIBRATE, [test "x$XCALIBRATE" = xyes])

if test "x$XCALIBRATE" = xyes; then

	AC_DEFINE(XCALIBRATE, 1, [Build XCalibrate extension])

	REQUIRED_MODULES="$REQUIRED_MODULES xcalibrateproto"

fi

/* Enable XCalibrate extension */

#undef XCALIBRATE

XCALIBRATE_SRCS = xcalibrate.c

if XCALIBRATE

BUILTIN_SRCS += $(XCALIBRATE_SRCS)

endif

	$(XCALIBRATE_SRCS) \

/*

 * $Id: xcalibrate.c,v 3.1 2004/06/02 20:49:50 pb Exp $

 *

 * Copyright © 2003 Philip Blundell

 *

 * Permission to use, copy, modify, distribute, and sell this software and its

 * documentation for any purpose is hereby granted without fee, provided that

 * the above copyright notice appear in all copies and that both that

 * copyright notice and this permission notice appear in supporting

 * documentation, and that the name of Philip Blundell not be used in

 * advertising or publicity pertaining to distribution of the software without

 * specific, written prior permission.  Philip Blundell makes no

 * representations about the suitability of this software for any purpose.  It

 * is provided "as is" without express or implied warranty.

 *

 * PHILIP BLUNDELL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,

 * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO

 * EVENT SHALL PHILIP BLUNDELL BE LIABLE FOR ANY SPECIAL, INDIRECT OR

 * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,

 * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER

 * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR

 * PERFORMANCE OF THIS SOFTWARE.

 */

#ifdef HAVE_KDRIVE_CONFIG_H

#include <kdrive-config.h>

#endif

#define NEED_EVENTS

#define NEED_REPLIES

#include <X11/X.h>

#include <X11/Xproto.h>

#include "misc.h"

#include "os.h"

#include "dixstruct.h"

#include "extnsionst.h"

#include "swaprep.h"

#include <X11/extensions/xcalibrateproto.h>

#include <X11/extensions/xcalibratewire.h>

extern void (*tslib_raw_event_hook)(int x, int y, int pressure, void *closure);

extern void *tslib_raw_event_closure;

static CARD8	XCalibrateReqCode;

int		XCalibrateEventBase;

int		XCalibrateReqBase;

int		XCalibrateErrorBase;

static ClientPtr xcalibrate_client;

static void

xcalibrate_event_hook (int x, int y, int pressure, void *closure)

{

  ClientPtr pClient = (ClientPtr) closure;

  xXCalibrateRawTouchscreenEvent	ev;

  ev.type = XCalibrateEventBase + X_XCalibrateRawTouchscreen;

  ev.sequenceNumber = pClient->sequence;

  ev.x = x;

  ev.y = y;

  ev.pressure = pressure;

  if (!pClient->clientGone)

    WriteEventsToClient (pClient, 1, (xEvent *) &ev);

}

static int

ProcXCalibrateQueryVersion (ClientPtr client)

{

  REQUEST(xXCalibrateQueryVersionReq);

  xXCalibrateQueryVersionReply rep;

  CARD16 client_major, client_minor;  /* not used */

  REQUEST_SIZE_MATCH (xXCalibrateQueryVersionReq);

  client_major = stuff->majorVersion;

  client_minor = stuff->minorVersion;

  fprintf(stderr, "%s(): called\n", __func__); 

  rep.type = X_Reply;

  rep.length = 0;

  rep.sequenceNumber = client->sequence;

  rep.majorVersion = XCALIBRATE_MAJOR_VERSION;

  rep.minorVersion = XCALIBRATE_MINOR_VERSION;   

  if (client->swapped) { 

    int n;

    swaps(&rep.sequenceNumber, n);

    swapl(&rep.length, n);     

    swaps(&rep.majorVersion, n);

    swaps(&rep.minorVersion, n);

  }

  WriteToClient(client, sizeof (xXCalibrateQueryVersionReply), (char *)&rep);

  return (client->noClientException);

}

static int

SProcXCalibrateQueryVersion (ClientPtr client)

{

    REQUEST(xXCalibrateQueryVersionReq);

    int n;

    REQUEST_SIZE_MATCH (xXCalibrateQueryVersionReq);

    swaps(&stuff->majorVersion,n);

    swaps(&stuff->minorVersion,n);

    return ProcXCalibrateQueryVersion(client);

}

static int

ProcXCalibrateSetRawMode (ClientPtr client)

{

  REQUEST(xXCalibrateRawModeReq);

  xXCalibrateRawModeReply rep;

  REQUEST_SIZE_MATCH (xXCalibrateRawModeReq);

  memset (&rep, 0, sizeof (rep));

  rep.type = X_Reply;

  rep.sequenceNumber = client->sequence;

  if (stuff->on)

    {

      if (xcalibrate_client == NULL)

	{

	  /* Start calibrating.  */

	  xcalibrate_client = client;

	  tslib_raw_event_hook = xcalibrate_event_hook;

	  tslib_raw_event_closure = client;

	  rep.status = GrabSuccess;

	}

      else

	{

	  rep.status = AlreadyGrabbed;

	}

    }

  else

    {

      if (xcalibrate_client == client)

	{

	  /* Stop calibrating.  */

	  xcalibrate_client = NULL;

	  tslib_raw_event_hook = NULL;

	  tslib_raw_event_closure = NULL;

	  rep.status = GrabSuccess;

	  /* Cycle input off and on to reload configuration.  */

	  KdDisableInput ();

	  KdEnableInput ();

	}

      else

	{

	  rep.status = AlreadyGrabbed;

	}

    }

  if (client->swapped)

    {

      int n;

      swaps (&rep.sequenceNumber, n);

      swaps (&rep.status, n);

    }

  WriteToClient(client, sizeof (rep), (char *) &rep);

  return (client->noClientException);

}

static int

SProcXCalibrateSetRawMode (ClientPtr client)

{

  REQUEST(xXCalibrateRawModeReq);

  int n;

  REQUEST_SIZE_MATCH (xXCalibrateRawModeReq);

  swaps(&stuff->on, n);

  return ProcXCalibrateSetRawMode(client);

}

static void

XCalibrateResetProc (ExtensionEntry *extEntry) 

{ 

}

static int

ProcXCalibrateDispatch (ClientPtr client)

{

    REQUEST(xReq);

    switch (stuff->data) {

    case X_XCalibrateQueryVersion:

        return ProcXCalibrateQueryVersion(client);

    case X_XCalibrateRawMode:

        return ProcXCalibrateSetRawMode(client);

    default: break;

    }

    return BadRequest;

}

static int

SProcXCalibrateDispatch (ClientPtr client)

{

    REQUEST(xReq);

    int n;

    swaps(&stuff->length,n);

    switch (stuff->data) {

    case X_XCalibrateQueryVersion:

        return SProcXCalibrateQueryVersion(client);

    case X_XCalibrateRawMode:

        return SProcXCalibrateSetRawMode(client);

    default: break;

    }

    return BadRequest;

}

static void

XCalibrateClientCallback (CallbackListPtr	*list,

			  pointer		closure,

			  pointer		data)

{

    NewClientInfoRec	*clientinfo = (NewClientInfoRec *) data;

    ClientPtr		pClient = clientinfo->client;

    if (clientinfo->setup == NULL

	&& xcalibrate_client != NULL

	&& xcalibrate_client == pClient)

      {

	/* Stop calibrating.  */

	xcalibrate_client = NULL;

	tslib_raw_event_hook = NULL;

	tslib_raw_event_closure = NULL;

      }

}

void

XCalibrateExtensionInit(void)

{

  ExtensionEntry *extEntry;

  if (!AddCallback (&ClientStateCallback, XCalibrateClientCallback, 0))

    return;  

  extEntry = AddExtension(XCALIBRATE_NAME, XCalibrateNumberEvents, XCalibrateNumberErrors,

			  ProcXCalibrateDispatch, SProcXCalibrateDispatch,

			  XCalibrateResetProc, StandardMinorOpcode);

  if (!extEntry)

    return;

  XCalibrateReqCode = (unsigned char)extEntry->base;

  XCalibrateEventBase = extEntry->eventBase;

  XCalibrateErrorBase = extEntry->errorBase;

  xcalibrate_client = 0;

}