Synchronised line endinge with release branch

6 files changed, 5993 insertions, 5993 deletions

diff --git a/xorg-server/hw/kdrive/ephyr/ephyr.c b/xorg-server/hw/kdrive/ephyr/ephyr.c
index 07c7643df..9cbb4b0ef 100644
--- a/xorg-server/hw/kdrive/ephyr/ephyr.c
+++ b/xorg-server/hw/kdrive/ephyr/ephyr.c
@@ -1,1188 +1,1188 @@
-/*

- * Xephyr - A kdrive X server thats runs in a host X window.

- *          Authored by Matthew Allum <mallum@openedhand.com>

- * 

- * Copyright © 2004 Nokia 

- *

- * 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 Nokia not be used in

- * advertising or publicity pertaining to distribution of the software without

- * specific, written prior permission. Nokia makes no

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

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

- *

- * NOKIA DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,

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

- * EVENT SHALL NOKIA 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_CONFIG_H

-#include <kdrive-config.h>

-#endif

-#include "ephyr.h"

-

-#include "inputstr.h"

-#include "scrnintstr.h"

-#include "ephyrlog.h"

-

-#ifdef XF86DRI

-#include "ephyrdri.h"

-#include "ephyrdriext.h"

-#include "ephyrglxext.h"

-#endif /* XF86DRI */

-

-#include "xkbsrv.h"

-

-extern int KdTsPhyScreen;

-#ifdef GLXEXT

-extern Bool noGlxVisualInit;

-#endif

-

-KdKeyboardInfo *ephyrKbd;

-KdPointerInfo *ephyrMouse;

-EphyrKeySyms ephyrKeySyms;

-Bool ephyrNoDRI=FALSE ;

-Bool ephyrNoXV=FALSE ;

-

-static int mouseState = 0;

-static Rotation ephyrRandr = RR_Rotate_0;

-

-typedef struct _EphyrInputPrivate {

-    Bool    enabled;

-} EphyrKbdPrivate, EphyrPointerPrivate;

-

-Bool   EphyrWantGrayScale = 0;

-

-

-Bool

-ephyrInitialize (KdCardInfo *card, EphyrPriv *priv)

-{

-#ifdef _MSC_VER

-  __asm int 3;

-#else

-  OsSignal(SIGUSR1, hostx_handle_signal);

-#endif  

-  priv->base = 0;

-  priv->bytes_per_line = 0;

-  return TRUE;

-}

-

-Bool

-ephyrCardInit (KdCardInfo *card)

-{

-  EphyrPriv	*priv;

-  

-  priv = (EphyrPriv *) malloc(sizeof (EphyrPriv));

-  if (!priv)

-    return FALSE;

-  

-  if (!ephyrInitialize (card, priv))

-    {

-      free(priv);

-      return FALSE;

-    }

-  card->driver = priv;

-  

-  return TRUE;

-}

-

-Bool

-ephyrScreenInitialize (KdScreenInfo *screen, EphyrScrPriv *scrpriv)

-{

-  int width = 640, height = 480; 

-  CARD32 redMask, greenMask, blueMask;

-  

-  if (hostx_want_screen_size(screen, &width, &height)

-      || !screen->width || !screen->height)

-    {

-      screen->width = width;

-      screen->height = height;

-    }

-

-  if (EphyrWantGrayScale)

-    screen->fb.depth = 8;

-

-  if (screen->fb.depth && screen->fb.depth != hostx_get_depth())

-    {

-      if (screen->fb.depth < hostx_get_depth()

-	  && (screen->fb.depth == 24 || screen->fb.depth == 16

-	      || screen->fb.depth == 8))

-	{

-	  hostx_set_server_depth(screen, screen->fb.depth);

-	}

-      else

-	ErrorF("\nXephyr: requested screen depth not supported, setting to match hosts.\n");

-    }

-  

-  screen->fb.depth = hostx_get_server_depth(screen);

-  screen->rate = 72;

-  

-  if (screen->fb.depth <= 8)

-    {

-      if (EphyrWantGrayScale)

-	screen->fb.visuals = ((1 << StaticGray) | (1 << GrayScale));

-      else

-	screen->fb.visuals = ((1 << StaticGray) |

-			      (1 << GrayScale) |

-			      (1 << StaticColor) |

-			      (1 << PseudoColor) |

-			      (1 << TrueColor) |

-			      (1 << DirectColor));

-      

-      screen->fb.redMask   = 0x00;

-      screen->fb.greenMask = 0x00;

-      screen->fb.blueMask  = 0x00;

-      screen->fb.depth        = 8;

-      screen->fb.bitsPerPixel = 8;

-    }

-  else 

-    {

-      screen->fb.visuals = (1 << TrueColor);

-      

-      if (screen->fb.depth <= 15)

-	{

-	  screen->fb.depth = 15;

-	  screen->fb.bitsPerPixel = 16;

-	}

-      else if (screen->fb.depth <= 16)

-	{

-	  screen->fb.depth = 16;

-	  screen->fb.bitsPerPixel = 16;

-	}

-      else if (screen->fb.depth <= 24)

-	{

-	  screen->fb.depth = 24;

-	  screen->fb.bitsPerPixel = 32;

-	}

-      else if (screen->fb.depth <= 30)

-	{

-	  screen->fb.depth = 30;

-	  screen->fb.bitsPerPixel = 32;

-	}

-      else

-	{

-	  ErrorF("\nXephyr: Unsupported screen depth %d\n",

-	         screen->fb.depth);

-	  return FALSE;

-	}

-

-      hostx_get_visual_masks (screen, &redMask, &greenMask, &blueMask);

-

-      screen->fb.redMask = (Pixel) redMask;

-      screen->fb.greenMask = (Pixel) greenMask;

-      screen->fb.blueMask = (Pixel) blueMask;

-

-    }

-  

-  scrpriv->randr = screen->randr;

-

-  return ephyrMapFramebuffer (screen);

-}

-

-Bool

-ephyrScreenInit (KdScreenInfo *screen)

-{

-  EphyrScrPriv *scrpriv;

-  

-  scrpriv = calloc(1, sizeof (EphyrScrPriv));

-

-  if (!scrpriv)

-    return FALSE;

-

-  screen->driver = scrpriv;

-

-  if (!ephyrScreenInitialize (screen, scrpriv))

-    {

-      screen->driver = 0;

-      free(scrpriv);

-      return FALSE;

-    }

-

-  return TRUE;

-}

-    

-void*

-ephyrWindowLinear (ScreenPtr	pScreen,

-		   CARD32	row,

-		   CARD32	offset,

-		   int		mode,

-		   CARD32	*size,

-		   void		*closure)

-{

-  KdScreenPriv(pScreen);

-  EphyrPriv	    *priv = pScreenPriv->card->driver;

-  

-  if (!pScreenPriv->enabled)

-    return 0;

-

-  *size = priv->bytes_per_line;

-  return priv->base + row * priv->bytes_per_line + offset;

-}

-

-/**

- * Figure out display buffer size. If fakexa is enabled, allocate a larger

- * buffer so that fakexa has space to put offscreen pixmaps.

- */

-int

-ephyrBufferHeight(KdScreenInfo *screen)

-{

-    int buffer_height;

-    if (ephyrFuncs.initAccel == NULL)

-	buffer_height = screen->height;

-    else

-	buffer_height = 3 * screen->height;

-    return buffer_height;

-}

-

-

-Bool

-ephyrMapFramebuffer (KdScreenInfo *screen)

-{

-  EphyrScrPriv  *scrpriv = screen->driver;

-  EphyrPriv	  *priv    = screen->card->driver;

-  KdPointerMatrix m;

-  int buffer_height;

-  

-  EPHYR_LOG("screen->width: %d, screen->height: %d index=%d",

-	     screen->width, screen->height, screen->mynum);

-  

-  /*

-   * Use the rotation last applied to ourselves (in the Xephyr case the fb

-   * coordinate system moves independently of the pointer coordiante system).

-   */

-  KdComputePointerMatrix (&m, ephyrRandr, screen->width, screen->height);

-  KdSetPointerMatrix (&m);

-  

-  priv->bytes_per_line = ((screen->width * screen->fb.bitsPerPixel + 31) >> 5) << 2;

-

-  buffer_height = ephyrBufferHeight(screen);

-

-  priv->base = hostx_screen_init (screen, screen->width, screen->height, buffer_height);

-

-  if ((scrpriv->randr & RR_Rotate_0) && !(scrpriv->randr & RR_Reflect_All))

-    {

-      scrpriv->shadow = FALSE;

-      

-      screen->fb.byteStride = priv->bytes_per_line;

-      screen->fb.pixelStride = screen->width;

-      screen->fb.frameBuffer = (CARD8 *) (priv->base);

-    }

-  else

-    {

-      /* Rotated/Reflected so we need to use shadow fb */

-      scrpriv->shadow = TRUE;

-      

-      EPHYR_LOG("allocing shadow");

-      

-      KdShadowFbAlloc (screen,

-		       scrpriv->randr & (RR_Rotate_90|RR_Rotate_270));

-    }

-  

-  return TRUE;

-}

-

-void

-ephyrSetScreenSizes (ScreenPtr pScreen)

-{

-  KdScreenPriv(pScreen);

-  KdScreenInfo	*screen = pScreenPriv->screen;

-  EphyrScrPriv	*scrpriv = screen->driver;

-  

-  if (scrpriv->randr & (RR_Rotate_0|RR_Rotate_180))

-    {

-      pScreen->width = screen->width;

-      pScreen->height = screen->height;

-      pScreen->mmWidth = screen->width_mm;

-      pScreen->mmHeight = screen->height_mm;

-    }

-  else 

-    {

-      pScreen->width = screen->height;

-      pScreen->height = screen->width;

-      pScreen->mmWidth = screen->height_mm;

-      pScreen->mmHeight = screen->width_mm;

-    }

-}

-

-Bool

-ephyrUnmapFramebuffer (KdScreenInfo *screen)

-{

-  EphyrScrPriv  *scrpriv = screen->driver;

-  

-  if (scrpriv->shadow)

-    KdShadowFbFree (screen);

-  

-  /* Note, priv->base will get freed when XImage recreated */

-  

-  return TRUE;

-}

-

-void 

-ephyrShadowUpdate (ScreenPtr pScreen, shadowBufPtr pBuf)

-{

-  KdScreenPriv(pScreen);

-  KdScreenInfo *screen = pScreenPriv->screen;

-  

-  EPHYR_LOG("slow paint");

-  

-  /* FIXME: Slow Rotated/Reflected updates could be much

-   * much faster efficiently updating via tranforming 

-   * pBuf->pDamage  regions     

-  */

-  shadowUpdateRotatePacked(pScreen, pBuf);

-  hostx_paint_rect(screen, 0,0,0,0, screen->width, screen->height);

-}

-

-static void

-ephyrInternalDamageRedisplay (ScreenPtr pScreen)

-{

-  KdScreenPriv(pScreen);

-  KdScreenInfo	*screen = pScreenPriv->screen;

-  EphyrScrPriv	*scrpriv = screen->driver;

-  RegionPtr	 pRegion;

-

-  if (!scrpriv || !scrpriv->pDamage)

-    return;

-

-  pRegion = DamageRegion (scrpriv->pDamage);

-

-  if (RegionNotEmpty(pRegion))

-    {

-      int           nbox;

-      BoxPtr        pbox;

-

-      nbox = RegionNumRects (pRegion);

-      pbox = RegionRects (pRegion);

-

-      while (nbox--)

-        {

-          hostx_paint_rect(screen,

-                           pbox->x1, pbox->y1,

-                           pbox->x1, pbox->y1,

-                           pbox->x2 - pbox->x1,

-                           pbox->y2 - pbox->y1);

-          pbox++;

-        }

-      DamageEmpty (scrpriv->pDamage);

-    }

-}

-

-static void

-ephyrInternalDamageBlockHandler (pointer   data,

-				 OSTimePtr pTimeout,

-				 pointer   pRead)

-{

-  ScreenPtr pScreen = (ScreenPtr) data;

-  

-  ephyrInternalDamageRedisplay (pScreen);

-}

-

-static void

-ephyrInternalDamageWakeupHandler (pointer data, int i, pointer LastSelectMask)

-{

-  /* FIXME: Not needed ? */

-}

-

-Bool

-ephyrSetInternalDamage (ScreenPtr pScreen)

-{

-  KdScreenPriv(pScreen);

-  KdScreenInfo	*screen = pScreenPriv->screen;

-  EphyrScrPriv	*scrpriv = screen->driver;

-  PixmapPtr      pPixmap = NULL;

-  

-  scrpriv->pDamage = DamageCreate ((DamageReportFunc) 0,

-				   (DamageDestroyFunc) 0,

-				   DamageReportNone,

-				   TRUE,

-				   pScreen,

-				   pScreen);

-  

-  if (!RegisterBlockAndWakeupHandlers (ephyrInternalDamageBlockHandler,

-				       ephyrInternalDamageWakeupHandler,

-				       (pointer) pScreen))

-    return FALSE;

-  

-  pPixmap = (*pScreen->GetScreenPixmap) (pScreen);

-  

-  DamageRegister (&pPixmap->drawable, scrpriv->pDamage);

-      

-  return TRUE;

-}

-

-void

-ephyrUnsetInternalDamage (ScreenPtr pScreen)

-{

-  KdScreenPriv(pScreen);

-  KdScreenInfo	*screen = pScreenPriv->screen;

-  EphyrScrPriv	*scrpriv = screen->driver;

-  PixmapPtr      pPixmap = NULL;

-  

-  pPixmap = (*pScreen->GetScreenPixmap) (pScreen);

-  DamageUnregister (&pPixmap->drawable, scrpriv->pDamage);

-  DamageDestroy (scrpriv->pDamage);

-  

-  RemoveBlockAndWakeupHandlers (ephyrInternalDamageBlockHandler,

-				ephyrInternalDamageWakeupHandler,

-				(pointer) pScreen);

-}

-

-#ifdef RANDR

-Bool

-ephyrRandRGetInfo (ScreenPtr pScreen, Rotation *rotations)

-{

-  KdScreenPriv(pScreen);

-  KdScreenInfo	    *screen = pScreenPriv->screen;

-  EphyrScrPriv	    *scrpriv = screen->driver;

-  RRScreenSizePtr	    pSize;

-  Rotation		    randr;

-  int			    n = 0;

- 

-  struct { int width, height; } sizes[] = 

-    {

-      { 1600, 1200 },

-      { 1400, 1050 },

-      { 1280, 960  },

-      { 1280, 1024 },

-      { 1152, 864 },

-      { 1024, 768 },

-      { 832, 624 },

-      { 800, 600 },

-      { 720, 400 },

-      { 480, 640 },

-      { 640, 480 },

-      { 640, 400 },

-      { 320, 240 },

-      { 240, 320 },

-      { 160, 160 }, 

-      { 0, 0 }

-    };

-

-  EPHYR_LOG("mark");

-

-  *rotations = RR_Rotate_All|RR_Reflect_All;

-

-  if (!hostx_want_preexisting_window (screen)

-      && !hostx_want_fullscreen ()) /* only if no -parent switch */

-    {

-      while (sizes[n].width != 0 && sizes[n].height != 0)

-	{

-	  RRRegisterSize (pScreen,

-			  sizes[n].width,

-			  sizes[n].height, 

-			  (sizes[n].width * screen->width_mm)/screen->width,

-			  (sizes[n].height *screen->height_mm)/screen->height

-			  );

-	  n++;

-	}

-    }

-  

-  pSize = RRRegisterSize (pScreen,

-			  screen->width,

-			  screen->height, 

-			  screen->width_mm,

-			  screen->height_mm);

-    

-  randr = KdSubRotation (scrpriv->randr, screen->randr);

-  

-  RRSetCurrentConfig (pScreen, randr, 0, pSize);

-    

-  return TRUE;

-}

-

-Bool

-ephyrRandRSetConfig (ScreenPtr		pScreen,

-		     Rotation		randr,

-		     int		rate,

-		     RRScreenSizePtr	pSize)

-{

-  KdScreenPriv(pScreen);

-  KdScreenInfo	*screen    = pScreenPriv->screen;

-  EphyrScrPriv	*scrpriv   = screen->driver;

-  Bool		wasEnabled = pScreenPriv->enabled;

-  EphyrScrPriv	oldscr;

-  int		oldwidth, oldheight, oldmmwidth, oldmmheight;

-  Bool          oldshadow;

-  int		newwidth, newheight;

-  

-  if (screen->randr & (RR_Rotate_0|RR_Rotate_180))

-    {

-      newwidth = pSize->width;

-      newheight = pSize->height;

-    }

-  else

-    {

-      newwidth = pSize->height;

-      newheight = pSize->width;

-    }

-  

-  if (wasEnabled)

-    KdDisableScreen (pScreen);

-

-  oldscr = *scrpriv;

-    

-  oldwidth    = screen->width;

-  oldheight   = screen->height;

-  oldmmwidth  = pScreen->mmWidth;

-  oldmmheight = pScreen->mmHeight;

-  oldshadow   = scrpriv->shadow;

-  

-  /*

-   * Set new configuration

-   */

-  

-  /*

-   * We need to store the rotation value for pointer coords transformation;

-   * though initially the pointer and fb rotation are identical, when we map

-   * the fb, the screen will be reinitialized and return into an unrotated

-   * state (presumably the HW is taking care of the rotation of the fb), but the

-   * pointer still needs to be transformed.

-   */

-  ephyrRandr = KdAddRotation (screen->randr, randr);

-  scrpriv->randr = ephyrRandr;

-  

-  ephyrUnmapFramebuffer (screen); 

-  

-  screen->width  = newwidth;

-  screen->height = newheight;

-  

-  if (!ephyrMapFramebuffer (screen))

-    goto bail4;

-  

-  /* FIXME below should go in own call */

-  

-  if (oldshadow)

-    KdShadowUnset (screen->pScreen);

-  else

-    ephyrUnsetInternalDamage(screen->pScreen);

-  

-  if (scrpriv->shadow)

-    {

-      if (!KdShadowSet (screen->pScreen, 

-			scrpriv->randr, 

-			ephyrShadowUpdate, 

-			ephyrWindowLinear))

-	goto bail4;

-    }

-  else

-    {

-      /* Without shadow fb ( non rotated ) we need 

-       * to use damage to efficiently update display

-       * via signal regions what to copy from 'fb'.

-       */

-      if (!ephyrSetInternalDamage(screen->pScreen))

-	goto bail4;

-    }

-  

-  ephyrSetScreenSizes (screen->pScreen);

-  

-  /*

-   * Set frame buffer mapping

-   */

-  (*pScreen->ModifyPixmapHeader) (fbGetScreenPixmap (pScreen),

-				  pScreen->width,

-				  pScreen->height,

-				  screen->fb.depth,

-				  screen->fb.bitsPerPixel,

-				  screen->fb.byteStride,

-				  screen->fb.frameBuffer);

-  

-  /* set the subpixel order */

-  

-  KdSetSubpixelOrder (pScreen, scrpriv->randr);

-  

-  if (wasEnabled)

-    KdEnableScreen (pScreen);

-  

-  return TRUE;

-  

- bail4:

-  EPHYR_LOG("bailed");

-  

-  ephyrUnmapFramebuffer (screen);

-  *scrpriv = oldscr;

-  (void) ephyrMapFramebuffer (screen);

-  

-  pScreen->width = oldwidth;

-  pScreen->height = oldheight;

-  pScreen->mmWidth = oldmmwidth;

-  pScreen->mmHeight = oldmmheight;

-  

-  if (wasEnabled)

-    KdEnableScreen (pScreen);

-  return FALSE;

-}

-

-Bool

-ephyrRandRInit (ScreenPtr pScreen)

-{

-  rrScrPrivPtr    pScrPriv;

-  

-  if (!RRScreenInit (pScreen))

-    return FALSE;

-  

-  pScrPriv = rrGetScrPriv(pScreen);

-  pScrPriv->rrGetInfo = ephyrRandRGetInfo;

-  pScrPriv->rrSetConfig = ephyrRandRSetConfig;

-  return TRUE;

-}

-#endif

-

-Bool

-ephyrCreateColormap (ColormapPtr pmap)

-{

-  return fbInitializeColormap (pmap);

-}

-

-Bool

-ephyrInitScreen (ScreenPtr pScreen)

-{

-  KdScreenPriv(pScreen);

-  KdScreenInfo	*screen    = pScreenPriv->screen;

-

-  EPHYR_LOG ("pScreen->myNum:%d\n", pScreen->myNum) ;

-  hostx_set_screen_number (screen, pScreen->myNum);

-  hostx_set_win_title (screen, "(ctrl+shift grabs mouse and keyboard)") ;

-  pScreen->CreateColormap = ephyrCreateColormap;

-

-#ifdef XV

-  if (!ephyrNoXV) {

-      if (!ephyrInitVideo (pScreen)) {

-          EPHYR_LOG_ERROR ("failed to initialize xvideo\n") ;

-      } else {

-          EPHYR_LOG ("initialized xvideo okay\n") ;

-      }

-  }

-#endif /*XV*/

-

-#ifdef XF86DRI

-  if (!ephyrNoDRI && !hostx_has_dri ()) {

-      EPHYR_LOG ("host x does not support DRI. Disabling DRI forwarding\n") ;

-      ephyrNoDRI = TRUE ;

-#ifdef GLXEXT

-      noGlxVisualInit = FALSE ;

-#endif

-  }

-  if (!ephyrNoDRI) {

-    ephyrDRIExtensionInit (pScreen) ;

-    ephyrHijackGLXExtension () ;

-  }

-#endif

-

-#ifdef GLXEXT

-  if (ephyrNoDRI) {

-      noGlxVisualInit = FALSE ;

-  }

-#endif

-

-  return TRUE;

-}

-

-Bool

-ephyrFinishInitScreen (ScreenPtr pScreen)

-{

-  /* FIXME: Calling this even if not using shadow.  

-   * Seems harmless enough. But may be safer elsewhere.

-   */

-  if (!shadowSetup (pScreen))

-    return FALSE;

-

-#ifdef RANDR

-  if (!ephyrRandRInit (pScreen))

-    return FALSE;

-#endif

-

-  return TRUE;

-}

-

-Bool

-ephyrCreateResources (ScreenPtr pScreen)

-{

-  KdScreenPriv(pScreen);

-  KdScreenInfo	*screen    = pScreenPriv->screen;

-  EphyrScrPriv	*scrpriv   = screen->driver;

-

-  EPHYR_LOG("mark pScreen=%p mynum=%d shadow=%d",

-            pScreen, pScreen->myNum, scrpriv->shadow);

-

-  if (scrpriv->shadow) 

-    return KdShadowSet (pScreen, 

-			scrpriv->randr, 

-			ephyrShadowUpdate, 

-			ephyrWindowLinear);

-  else

-    return ephyrSetInternalDamage(pScreen); 

-}

-

-void

-ephyrPreserve (KdCardInfo *card)

-{

-}

-

-Bool

-ephyrEnable (ScreenPtr pScreen)

-{

-  return TRUE;

-}

-

-Bool

-ephyrDPMS (ScreenPtr pScreen, int mode)

-{

-  return TRUE;

-}

-

-void

-ephyrDisable (ScreenPtr pScreen)

-{

-}

-

-void

-ephyrRestore (KdCardInfo *card)

-{

-}

-

-void

-ephyrScreenFini (KdScreenInfo *screen)

-{

-    EphyrScrPriv  *scrpriv = screen->driver;

-    if (scrpriv->shadow) {

-        KdShadowFbFree (screen);

-    }

-    free(screen->driver);

-    screen->driver = NULL;

-}

-

-/*  

- * Port of Mark McLoughlin's Xnest fix for focus in + modifier bug.

- * See https://bugs.freedesktop.org/show_bug.cgi?id=3030

- */

-void

-ephyrUpdateModifierState(unsigned int state)

-{

-

-  DeviceIntPtr pDev = inputInfo.keyboard;

-  KeyClassPtr keyc = pDev->key;

-  int i;

-  CARD8 mask;

-  int xkb_state;

-  

-  if (!pDev)

-      return;

-

-  xkb_state = XkbStateFieldFromRec(&pDev->key->xkbInfo->state);

-  state = state & 0xff;

-

-  if (xkb_state == state)

-    return;

-      

-  for (i = 0, mask = 1; i < 8; i++, mask <<= 1) {

-    int key;

-

-    /* Modifier is down, but shouldn't be

-     */

-    if ((xkb_state & mask) && !(state & mask)) {

-      int count = keyc->modifierKeyCount[i];

-

-      for (key = 0; key < MAP_LENGTH; key++)

-        if (keyc->xkbInfo->desc->map->modmap[key] & mask) {

-          if (key_is_down(pDev, key, KEY_PROCESSED))

-	        KdEnqueueKeyboardEvent (ephyrKbd, key, TRUE);

-

-          if (--count == 0)

-            break;

-        }

-    }

-

-    /* Modifier shoud be down, but isn't

-     */

-    if (!(xkb_state & mask) && (state & mask))

-      for (key = 0; key < MAP_LENGTH; key++)

-        if (keyc->xkbInfo->desc->map->modmap[key] & mask) {

-	        KdEnqueueKeyboardEvent (ephyrKbd, key, FALSE);

-          break;

-        }

-  }

-}

-

-static void

-ephyrBlockSigio (void)

-{

-#ifdef _MSC_VER

-    __asm int 3;

-#else

-    sigset_t set;

-

-    sigemptyset (&set);

-    sigaddset (&set, SIGIO);

-    sigprocmask (SIG_BLOCK, &set, 0);

-#endif

-}

-

-static void

-ephyrUnblockSigio (void)

-{

-#ifdef _MSC_VER

-    __asm int 3;

-#else

-    sigset_t set;

-

-    sigemptyset (&set);

-    sigaddset (&set, SIGIO);

-    sigprocmask (SIG_UNBLOCK, &set, 0);

-#endif

-}

-

-static Bool

-ephyrCursorOffScreen(ScreenPtr *ppScreen, int *x, int *y)

-{

-  return FALSE;

-}

-

-static void

-ephyrCrossScreen (ScreenPtr pScreen, Bool entering)

-{

-}

-

-int ephyrCurScreen; /*current event screen*/

-

-static void

-ephyrWarpCursor (DeviceIntPtr pDev, ScreenPtr pScreen, int x, int y)

-{

-    ephyrBlockSigio ();

-    ephyrCurScreen = pScreen->myNum;

-    miPointerWarpCursor (inputInfo.pointer, pScreen, x, y);

-    ephyrUnblockSigio ();

-}

-

-miPointerScreenFuncRec ephyrPointerScreenFuncs =

-{

-  ephyrCursorOffScreen,

-  ephyrCrossScreen,

-  ephyrWarpCursor,

-  NULL,

-  NULL

-};

-

-#ifdef XF86DRI

-/**

- * find if the remote window denoted by a_remote

- * is paired with an internal Window within the Xephyr server.

- * If the remove window is paired with an internal window, send an

- * expose event to the client insterested in the internal window expose event.

- *

- * Pairing happens when a drawable inside Xephyr is associated with

- * a GL surface in a DRI environment.

- * Look at the function ProcXF86DRICreateDrawable in ephyrdriext.c to

- * know a paired window is created.

- *

- * This is useful to make GL drawables (only windows for now) handle

- * expose events and send those events to clients.

- */

-static void

-ephyrExposePairedWindow (int a_remote)

-{

-    EphyrWindowPair *pair = NULL;

-    RegionRec reg;

-    ScreenPtr screen;

-

-    if (!findWindowPairFromRemote (a_remote, &pair)) {

-	EPHYR_LOG ("did not find a pair for this window\n");

-	return;

-    }

-    screen = pair->local->drawable.pScreen;

-    RegionNull(&reg);

-    RegionCopy(&reg, &pair->local->clipList);

-    screen->WindowExposures (pair->local, &reg, NullRegion);

-    RegionUninit(&reg);

-}

-#endif /* XF86DRI */

-

-void

-ephyrPoll(void)

-{

-  EphyrHostXEvent ev;

-

-  while (hostx_get_event(&ev))

-    {

-      switch (ev.type)

-        {

-        case EPHYR_EV_MOUSE_MOTION:

-          if (!ephyrMouse ||

-              !((EphyrPointerPrivate *)ephyrMouse->driverPrivate)->enabled) {

-              EPHYR_LOG ("skipping mouse motion:%d\n", ephyrCurScreen) ;

-              continue;

-          }

-          {

-            if (ev.data.mouse_motion.screen >=0

-                && (ephyrCurScreen != ev.data.mouse_motion.screen))

-              {

-                  EPHYR_LOG ("warping mouse cursor. "

-                             "cur_screen%d, motion_screen:%d\n",

-                             ephyrCurScreen, ev.data.mouse_motion.screen) ;

-                  if (ev.data.mouse_motion.screen >= 0)

-                    {

-                      ephyrWarpCursor

-                            (inputInfo.pointer, screenInfo.screens[ev.data.mouse_motion.screen],

-                             ev.data.mouse_motion.x,

-                             ev.data.mouse_motion.y );

-                    }

-              }

-            else

-              {

-                  int x=0, y=0;

-#ifdef XF86DRI

-                  EphyrWindowPair *pair = NULL;

-#endif

-                  EPHYR_LOG ("enqueuing mouse motion:%d\n", ephyrCurScreen) ;

-                  x = ev.data.mouse_motion.x;

-                  y = ev.data.mouse_motion.y;

-                  EPHYR_LOG ("initial (x,y):(%d,%d)\n", x, y) ;

-#ifdef XF86DRI

-                  EPHYR_LOG ("is this window peered by a gl drawable ?\n") ;

-                  if (findWindowPairFromRemote (ev.data.mouse_motion.window,

-                                                &pair))

-                    {

-                        EPHYR_LOG ("yes, it is peered\n") ;

-                        x += pair->local->drawable.x;

-                        y += pair->local->drawable.y;

-                    }

-                  else

-                    {

-                        EPHYR_LOG ("no, it is not peered\n") ;

-                    }

-                  EPHYR_LOG ("final (x,y):(%d,%d)\n", x, y) ;

-#endif

-                  KdEnqueuePointerEvent(ephyrMouse, mouseState, x, y, 0);

-              }

-          }

-          break;

-

-        case EPHYR_EV_MOUSE_PRESS:

-          if (!ephyrMouse ||

-              !((EphyrPointerPrivate *)ephyrMouse->driverPrivate)->enabled) {

-              EPHYR_LOG ("skipping mouse press:%d\n", ephyrCurScreen) ;

-              continue;

-          }

-          EPHYR_LOG ("enqueuing mouse press:%d\n", ephyrCurScreen) ;

-	  ephyrUpdateModifierState(ev.key_state);

-	  mouseState |= ev.data.mouse_down.button_num;

-	  KdEnqueuePointerEvent(ephyrMouse, mouseState|KD_MOUSE_DELTA, 0, 0, 0);

-	  break;

-

-	case EPHYR_EV_MOUSE_RELEASE:

-          if (!ephyrMouse ||

-              !((EphyrPointerPrivate *)ephyrMouse->driverPrivate)->enabled)

-              continue;

-	  ephyrUpdateModifierState(ev.key_state);

-	  mouseState &= ~ev.data.mouse_up.button_num;

-          EPHYR_LOG ("enqueuing mouse release:%d\n", ephyrCurScreen) ;

-	  KdEnqueuePointerEvent(ephyrMouse, mouseState|KD_MOUSE_DELTA, 0, 0, 0);

-	  break;

-

-	case EPHYR_EV_KEY_PRESS:

-          if (!ephyrKbd ||

-              !((EphyrKbdPrivate *)ephyrKbd->driverPrivate)->enabled)

-              continue;

-	  ephyrUpdateModifierState(ev.key_state);

-	  KdEnqueueKeyboardEvent (ephyrKbd, ev.data.key_down.scancode, FALSE);

-	  break;

-

-	case EPHYR_EV_KEY_RELEASE:

-          if (!ephyrKbd ||

-              !((EphyrKbdPrivate *)ephyrKbd->driverPrivate)->enabled)

-              continue;

-	  ephyrUpdateModifierState(ev.key_state);

-	  KdEnqueueKeyboardEvent (ephyrKbd, ev.data.key_up.scancode, TRUE);

-	  break;

-

-#ifdef XF86DRI

-	case EPHYR_EV_EXPOSE:

-	  /*

-	   * We only receive expose events when the expose event have

-	   * be generated for a drawable that is a host X window managed

-	   * by Xephyr. Host X windows managed by Xephyr exists for instance

-	   * when Xephyr is asked to create a GL drawable in a DRI environment.

-	   */

-	  ephyrExposePairedWindow (ev.data.expose.window);

-	  break;

-#endif /* XF86DRI */

-

-	default:

-	  break;

-	}

-    }

-}

-

-void

-ephyrCardFini (KdCardInfo *card)

-{

-  EphyrPriv	*priv = card->driver;

-  free(priv);

-}

-

-void

-ephyrGetColors (ScreenPtr pScreen, int n, xColorItem *pdefs)

-{

-  /* XXX Not sure if this is right */

-  

-  EPHYR_LOG("mark");

-  

-  while (n--)

-    {

-      pdefs->red = 0;

-      pdefs->green = 0;

-      pdefs->blue = 0;

-      pdefs++;

-    }

-

-}

-

-void

-ephyrPutColors (ScreenPtr pScreen, int n, xColorItem *pdefs)

-{

-  int min, max, p;

-

-  /* XXX Not sure if this is right */

-

-  min = 256;

-  max = 0;

-  

-  while (n--)

-    {

-      p = pdefs->pixel;

-      if (p < min)

-	min = p;

-      if (p > max)

-	max = p;

-

-      hostx_set_cmap_entry(p, 		

-			   pdefs->red >> 8,

-			   pdefs->green >> 8,

-			   pdefs->blue >> 8);

-      pdefs++;

-    }

-}

-

-/* Mouse calls */

-

-static Status

-MouseInit (KdPointerInfo *pi)

-{

-    pi->driverPrivate = (EphyrPointerPrivate *)

-                         calloc(sizeof(EphyrPointerPrivate), 1);

-    ((EphyrPointerPrivate *)pi->driverPrivate)->enabled = FALSE;

-    pi->nAxes = 3;

-    pi->nButtons = 32;

-    free(pi->name);

-    pi->name = strdup("Xephyr virtual mouse");

-

-    /*

-     * Must transform pointer coords since the pointer position

-     * relative to the Xephyr window is controlled by the host server and

-     * remains constant regardless of any rotation applied to the Xephyr screen.

-     */

-    pi->transformCoordinates = TRUE;

-

-    ephyrMouse = pi;

-    return Success;

-}

-

-static Status

-MouseEnable (KdPointerInfo *pi)

-{

-    ((EphyrPointerPrivate *)pi->driverPrivate)->enabled = TRUE;

-    return Success;

-}

-

-static void

-MouseDisable (KdPointerInfo *pi)

-{

-    ((EphyrPointerPrivate *)pi->driverPrivate)->enabled = FALSE;

-    return;

-}

-

-static void

-MouseFini (KdPointerInfo *pi)

-{

-    ephyrMouse = NULL; 

-    return;

-}

-

-KdPointerDriver EphyrMouseDriver = {

-    "ephyr",

-    MouseInit,

-    MouseEnable,

-    MouseDisable,

-    MouseFini,

-    NULL,

-};

-

-/* Keyboard */

-

-static Status

-EphyrKeyboardInit (KdKeyboardInfo *ki)

-{

-  ki->driverPrivate = (EphyrKbdPrivate *)

-                       calloc(sizeof(EphyrKbdPrivate), 1);

-  hostx_load_keymap();

-  if (!ephyrKeySyms.map) {

-      ErrorF("Couldn't load keymap from host\n");

-      return BadAlloc;

-  }

-  ki->minScanCode = ephyrKeySyms.minKeyCode;

-  ki->maxScanCode = ephyrKeySyms.maxKeyCode;

-  free(ki->name);

-  ki->name = strdup("Xephyr virtual keyboard");

-  ephyrKbd = ki;

-  return Success;

-}

-

-static Status

-EphyrKeyboardEnable (KdKeyboardInfo *ki)

-{

-    ((EphyrKbdPrivate *)ki->driverPrivate)->enabled = TRUE;

-

-    return Success;

-}

-

-static void

-EphyrKeyboardDisable (KdKeyboardInfo *ki)

-{

-    ((EphyrKbdPrivate *)ki->driverPrivate)->enabled = FALSE;

-}

-

-static void

-EphyrKeyboardFini (KdKeyboardInfo *ki)

-{

-    ephyrKbd = NULL;

-    return;

-}

-

-static void

-EphyrKeyboardLeds (KdKeyboardInfo *ki, int leds)

-{

-}

-

-static void

-EphyrKeyboardBell (KdKeyboardInfo *ki, int volume, int frequency, int duration)

-{

-}

-

-

-KdKeyboardDriver EphyrKeyboardDriver = {

-    "ephyr",

-    EphyrKeyboardInit,

-    EphyrKeyboardEnable,

-    EphyrKeyboardLeds,

-    EphyrKeyboardBell,

-    EphyrKeyboardDisable,

-    EphyrKeyboardFini,

-    NULL,

-};

+/*
+ * Xephyr - A kdrive X server thats runs in a host X window.
+ *          Authored by Matthew Allum <mallum@openedhand.com>
+ * 
+ * Copyright © 2004 Nokia 
+ *
+ * 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 Nokia not be used in
+ * advertising or publicity pertaining to distribution of the software without
+ * specific, written prior permission. Nokia makes no
+ * representations about the suitability of this software for any purpose.  It
+ * is provided "as is" without express or implied warranty.
+ *
+ * NOKIA DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
+ * EVENT SHALL NOKIA 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_CONFIG_H
+#include <kdrive-config.h>
+#endif
+#include "ephyr.h"
+
+#include "inputstr.h"
+#include "scrnintstr.h"
+#include "ephyrlog.h"
+
+#ifdef XF86DRI
+#include "ephyrdri.h"
+#include "ephyrdriext.h"
+#include "ephyrglxext.h"
+#endif /* XF86DRI */
+
+#include "xkbsrv.h"
+
+extern int KdTsPhyScreen;
+#ifdef GLXEXT
+extern Bool noGlxVisualInit;
+#endif
+
+KdKeyboardInfo *ephyrKbd;
+KdPointerInfo *ephyrMouse;
+EphyrKeySyms ephyrKeySyms;
+Bool ephyrNoDRI=FALSE ;
+Bool ephyrNoXV=FALSE ;
+
+static int mouseState = 0;
+static Rotation ephyrRandr = RR_Rotate_0;
+
+typedef struct _EphyrInputPrivate {
+    Bool    enabled;
+} EphyrKbdPrivate, EphyrPointerPrivate;
+
+Bool   EphyrWantGrayScale = 0;
+
+
+Bool
+ephyrInitialize (KdCardInfo *card, EphyrPriv *priv)
+{
+#ifdef _MSC_VER
+  __asm int 3;
+#else
+  OsSignal(SIGUSR1, hostx_handle_signal);
+#endif  
+  priv->base = 0;
+  priv->bytes_per_line = 0;
+  return TRUE;
+}
+
+Bool
+ephyrCardInit (KdCardInfo *card)
+{
+  EphyrPriv	*priv;
+  
+  priv = (EphyrPriv *) malloc(sizeof (EphyrPriv));
+  if (!priv)
+    return FALSE;
+  
+  if (!ephyrInitialize (card, priv))
+    {
+      free(priv);
+      return FALSE;
+    }
+  card->driver = priv;
+  
+  return TRUE;
+}
+
+Bool
+ephyrScreenInitialize (KdScreenInfo *screen, EphyrScrPriv *scrpriv)
+{
+  int width = 640, height = 480; 
+  CARD32 redMask, greenMask, blueMask;
+  
+  if (hostx_want_screen_size(screen, &width, &height)
+      || !screen->width || !screen->height)
+    {
+      screen->width = width;
+      screen->height = height;
+    }
+
+  if (EphyrWantGrayScale)
+    screen->fb.depth = 8;
+
+  if (screen->fb.depth && screen->fb.depth != hostx_get_depth())
+    {
+      if (screen->fb.depth < hostx_get_depth()
+	  && (screen->fb.depth == 24 || screen->fb.depth == 16
+	      || screen->fb.depth == 8))
+	{
+	  hostx_set_server_depth(screen, screen->fb.depth);
+	}
+      else
+	ErrorF("\nXephyr: requested screen depth not supported, setting to match hosts.\n");
+    }
+  
+  screen->fb.depth = hostx_get_server_depth(screen);
+  screen->rate = 72;
+  
+  if (screen->fb.depth <= 8)
+    {
+      if (EphyrWantGrayScale)
+	screen->fb.visuals = ((1 << StaticGray) | (1 << GrayScale));
+      else
+	screen->fb.visuals = ((1 << StaticGray) |
+			      (1 << GrayScale) |
+			      (1 << StaticColor) |
+			      (1 << PseudoColor) |
+			      (1 << TrueColor) |
+			      (1 << DirectColor));
+      
+      screen->fb.redMask   = 0x00;
+      screen->fb.greenMask = 0x00;
+      screen->fb.blueMask  = 0x00;
+      screen->fb.depth        = 8;
+      screen->fb.bitsPerPixel = 8;
+    }
+  else 
+    {
+      screen->fb.visuals = (1 << TrueColor);
+      
+      if (screen->fb.depth <= 15)
+	{
+	  screen->fb.depth = 15;
+	  screen->fb.bitsPerPixel = 16;
+	}
+      else if (screen->fb.depth <= 16)
+	{
+	  screen->fb.depth = 16;
+	  screen->fb.bitsPerPixel = 16;
+	}
+      else if (screen->fb.depth <= 24)
+	{
+	  screen->fb.depth = 24;
+	  screen->fb.bitsPerPixel = 32;
+	}
+      else if (screen->fb.depth <= 30)
+	{
+	  screen->fb.depth = 30;
+	  screen->fb.bitsPerPixel = 32;
+	}
+      else
+	{
+	  ErrorF("\nXephyr: Unsupported screen depth %d\n",
+	         screen->fb.depth);
+	  return FALSE;
+	}
+
+      hostx_get_visual_masks (screen, &redMask, &greenMask, &blueMask);
+
+      screen->fb.redMask = (Pixel) redMask;
+      screen->fb.greenMask = (Pixel) greenMask;
+      screen->fb.blueMask = (Pixel) blueMask;
+
+    }
+  
+  scrpriv->randr = screen->randr;
+
+  return ephyrMapFramebuffer (screen);
+}
+
+Bool
+ephyrScreenInit (KdScreenInfo *screen)
+{
+  EphyrScrPriv *scrpriv;
+  
+  scrpriv = calloc(1, sizeof (EphyrScrPriv));
+
+  if (!scrpriv)
+    return FALSE;
+
+  screen->driver = scrpriv;
+
+  if (!ephyrScreenInitialize (screen, scrpriv))
+    {
+      screen->driver = 0;
+      free(scrpriv);
+      return FALSE;
+    }
+
+  return TRUE;
+}
+    
+void*
+ephyrWindowLinear (ScreenPtr	pScreen,
+		   CARD32	row,
+		   CARD32	offset,
+		   int		mode,
+		   CARD32	*size,
+		   void		*closure)
+{
+  KdScreenPriv(pScreen);
+  EphyrPriv	    *priv = pScreenPriv->card->driver;
+  
+  if (!pScreenPriv->enabled)
+    return 0;
+
+  *size = priv->bytes_per_line;
+  return priv->base + row * priv->bytes_per_line + offset;
+}
+
+/**
+ * Figure out display buffer size. If fakexa is enabled, allocate a larger
+ * buffer so that fakexa has space to put offscreen pixmaps.
+ */
+int
+ephyrBufferHeight(KdScreenInfo *screen)
+{
+    int buffer_height;
+    if (ephyrFuncs.initAccel == NULL)
+	buffer_height = screen->height;
+    else
+	buffer_height = 3 * screen->height;
+    return buffer_height;
+}
+
+
+Bool
+ephyrMapFramebuffer (KdScreenInfo *screen)
+{
+  EphyrScrPriv  *scrpriv = screen->driver;
+  EphyrPriv	  *priv    = screen->card->driver;
+  KdPointerMatrix m;
+  int buffer_height;
+  
+  EPHYR_LOG("screen->width: %d, screen->height: %d index=%d",
+	     screen->width, screen->height, screen->mynum);
+  
+  /*
+   * Use the rotation last applied to ourselves (in the Xephyr case the fb
+   * coordinate system moves independently of the pointer coordiante system).
+   */
+  KdComputePointerMatrix (&m, ephyrRandr, screen->width, screen->height);
+  KdSetPointerMatrix (&m);
+  
+  priv->bytes_per_line = ((screen->width * screen->fb.bitsPerPixel + 31) >> 5) << 2;
+
+  buffer_height = ephyrBufferHeight(screen);
+
+  priv->base = hostx_screen_init (screen, screen->width, screen->height, buffer_height);
+
+  if ((scrpriv->randr & RR_Rotate_0) && !(scrpriv->randr & RR_Reflect_All))
+    {
+      scrpriv->shadow = FALSE;
+      
+      screen->fb.byteStride = priv->bytes_per_line;
+      screen->fb.pixelStride = screen->width;
+      screen->fb.frameBuffer = (CARD8 *) (priv->base);
+    }
+  else
+    {
+      /* Rotated/Reflected so we need to use shadow fb */
+      scrpriv->shadow = TRUE;
+      
+      EPHYR_LOG("allocing shadow");
+      
+      KdShadowFbAlloc (screen,
+		       scrpriv->randr & (RR_Rotate_90|RR_Rotate_270));
+    }
+  
+  return TRUE;
+}
+
+void
+ephyrSetScreenSizes (ScreenPtr pScreen)
+{
+  KdScreenPriv(pScreen);
+  KdScreenInfo	*screen = pScreenPriv->screen;
+  EphyrScrPriv	*scrpriv = screen->driver;
+  
+  if (scrpriv->randr & (RR_Rotate_0|RR_Rotate_180))
+    {
+      pScreen->width = screen->width;
+      pScreen->height = screen->height;
+      pScreen->mmWidth = screen->width_mm;
+      pScreen->mmHeight = screen->height_mm;
+    }
+  else 
+    {
+      pScreen->width = screen->height;
+      pScreen->height = screen->width;
+      pScreen->mmWidth = screen->height_mm;
+      pScreen->mmHeight = screen->width_mm;
+    }
+}
+
+Bool
+ephyrUnmapFramebuffer (KdScreenInfo *screen)
+{
+  EphyrScrPriv  *scrpriv = screen->driver;
+  
+  if (scrpriv->shadow)
+    KdShadowFbFree (screen);
+  
+  /* Note, priv->base will get freed when XImage recreated */
+  
+  return TRUE;
+}
+
+void 
+ephyrShadowUpdate (ScreenPtr pScreen, shadowBufPtr pBuf)
+{
+  KdScreenPriv(pScreen);
+  KdScreenInfo *screen = pScreenPriv->screen;
+  
+  EPHYR_LOG("slow paint");
+  
+  /* FIXME: Slow Rotated/Reflected updates could be much
+   * much faster efficiently updating via tranforming 
+   * pBuf->pDamage  regions     
+  */
+  shadowUpdateRotatePacked(pScreen, pBuf);
+  hostx_paint_rect(screen, 0,0,0,0, screen->width, screen->height);
+}
+
+static void
+ephyrInternalDamageRedisplay (ScreenPtr pScreen)
+{
+  KdScreenPriv(pScreen);
+  KdScreenInfo	*screen = pScreenPriv->screen;
+  EphyrScrPriv	*scrpriv = screen->driver;
+  RegionPtr	 pRegion;
+
+  if (!scrpriv || !scrpriv->pDamage)
+    return;
+
+  pRegion = DamageRegion (scrpriv->pDamage);
+
+  if (RegionNotEmpty(pRegion))
+    {
+      int           nbox;
+      BoxPtr        pbox;
+
+      nbox = RegionNumRects (pRegion);
+      pbox = RegionRects (pRegion);
+
+      while (nbox--)
+        {
+          hostx_paint_rect(screen,
+                           pbox->x1, pbox->y1,
+                           pbox->x1, pbox->y1,
+                           pbox->x2 - pbox->x1,
+                           pbox->y2 - pbox->y1);
+          pbox++;
+        }
+      DamageEmpty (scrpriv->pDamage);
+    }
+}
+
+static void
+ephyrInternalDamageBlockHandler (pointer   data,
+				 OSTimePtr pTimeout,
+				 pointer   pRead)
+{
+  ScreenPtr pScreen = (ScreenPtr) data;
+  
+  ephyrInternalDamageRedisplay (pScreen);
+}
+
+static void
+ephyrInternalDamageWakeupHandler (pointer data, int i, pointer LastSelectMask)
+{
+  /* FIXME: Not needed ? */
+}
+
+Bool
+ephyrSetInternalDamage (ScreenPtr pScreen)
+{
+  KdScreenPriv(pScreen);
+  KdScreenInfo	*screen = pScreenPriv->screen;
+  EphyrScrPriv	*scrpriv = screen->driver;
+  PixmapPtr      pPixmap = NULL;
+  
+  scrpriv->pDamage = DamageCreate ((DamageReportFunc) 0,
+				   (DamageDestroyFunc) 0,
+				   DamageReportNone,
+				   TRUE,
+				   pScreen,
+				   pScreen);
+  
+  if (!RegisterBlockAndWakeupHandlers (ephyrInternalDamageBlockHandler,
+				       ephyrInternalDamageWakeupHandler,
+				       (pointer) pScreen))
+    return FALSE;
+  
+  pPixmap = (*pScreen->GetScreenPixmap) (pScreen);
+  
+  DamageRegister (&pPixmap->drawable, scrpriv->pDamage);
+      
+  return TRUE;
+}
+
+void
+ephyrUnsetInternalDamage (ScreenPtr pScreen)
+{
+  KdScreenPriv(pScreen);
+  KdScreenInfo	*screen = pScreenPriv->screen;
+  EphyrScrPriv	*scrpriv = screen->driver;
+  PixmapPtr      pPixmap = NULL;
+  
+  pPixmap = (*pScreen->GetScreenPixmap) (pScreen);
+  DamageUnregister (&pPixmap->drawable, scrpriv->pDamage);
+  DamageDestroy (scrpriv->pDamage);
+  
+  RemoveBlockAndWakeupHandlers (ephyrInternalDamageBlockHandler,
+				ephyrInternalDamageWakeupHandler,
+				(pointer) pScreen);
+}
+
+#ifdef RANDR
+Bool
+ephyrRandRGetInfo (ScreenPtr pScreen, Rotation *rotations)
+{
+  KdScreenPriv(pScreen);
+  KdScreenInfo	    *screen = pScreenPriv->screen;
+  EphyrScrPriv	    *scrpriv = screen->driver;
+  RRScreenSizePtr	    pSize;
+  Rotation		    randr;
+  int			    n = 0;
+ 
+  struct { int width, height; } sizes[] = 
+    {
+      { 1600, 1200 },
+      { 1400, 1050 },
+      { 1280, 960  },
+      { 1280, 1024 },
+      { 1152, 864 },
+      { 1024, 768 },
+      { 832, 624 },
+      { 800, 600 },
+      { 720, 400 },
+      { 480, 640 },
+      { 640, 480 },
+      { 640, 400 },
+      { 320, 240 },
+      { 240, 320 },
+      { 160, 160 }, 
+      { 0, 0 }
+    };
+
+  EPHYR_LOG("mark");
+
+  *rotations = RR_Rotate_All|RR_Reflect_All;
+
+  if (!hostx_want_preexisting_window (screen)
+      && !hostx_want_fullscreen ()) /* only if no -parent switch */
+    {
+      while (sizes[n].width != 0 && sizes[n].height != 0)
+	{
+	  RRRegisterSize (pScreen,
+			  sizes[n].width,
+			  sizes[n].height, 
+			  (sizes[n].width * screen->width_mm)/screen->width,
+			  (sizes[n].height *screen->height_mm)/screen->height
+			  );
+	  n++;
+	}
+    }
+  
+  pSize = RRRegisterSize (pScreen,
+			  screen->width,
+			  screen->height, 
+			  screen->width_mm,
+			  screen->height_mm);
+    
+  randr = KdSubRotation (scrpriv->randr, screen->randr);
+  
+  RRSetCurrentConfig (pScreen, randr, 0, pSize);
+    
+  return TRUE;
+}
+
+Bool
+ephyrRandRSetConfig (ScreenPtr		pScreen,
+		     Rotation		randr,
+		     int		rate,
+		     RRScreenSizePtr	pSize)
+{
+  KdScreenPriv(pScreen);
+  KdScreenInfo	*screen    = pScreenPriv->screen;
+  EphyrScrPriv	*scrpriv   = screen->driver;
+  Bool		wasEnabled = pScreenPriv->enabled;
+  EphyrScrPriv	oldscr;
+  int		oldwidth, oldheight, oldmmwidth, oldmmheight;
+  Bool          oldshadow;
+  int		newwidth, newheight;
+  
+  if (screen->randr & (RR_Rotate_0|RR_Rotate_180))
+    {
+      newwidth = pSize->width;
+      newheight = pSize->height;
+    }
+  else
+    {
+      newwidth = pSize->height;
+      newheight = pSize->width;
+    }
+  
+  if (wasEnabled)
+    KdDisableScreen (pScreen);
+
+  oldscr = *scrpriv;
+    
+  oldwidth    = screen->width;
+  oldheight   = screen->height;
+  oldmmwidth  = pScreen->mmWidth;
+  oldmmheight = pScreen->mmHeight;
+  oldshadow   = scrpriv->shadow;
+  
+  /*
+   * Set new configuration
+   */
+  
+  /*
+   * We need to store the rotation value for pointer coords transformation;
+   * though initially the pointer and fb rotation are identical, when we map
+   * the fb, the screen will be reinitialized and return into an unrotated
+   * state (presumably the HW is taking care of the rotation of the fb), but the
+   * pointer still needs to be transformed.
+   */
+  ephyrRandr = KdAddRotation (screen->randr, randr);
+  scrpriv->randr = ephyrRandr;
+  
+  ephyrUnmapFramebuffer (screen); 
+  
+  screen->width  = newwidth;
+  screen->height = newheight;
+  
+  if (!ephyrMapFramebuffer (screen))
+    goto bail4;
+  
+  /* FIXME below should go in own call */
+  
+  if (oldshadow)
+    KdShadowUnset (screen->pScreen);
+  else
+    ephyrUnsetInternalDamage(screen->pScreen);
+  
+  if (scrpriv->shadow)
+    {
+      if (!KdShadowSet (screen->pScreen, 
+			scrpriv->randr, 
+			ephyrShadowUpdate, 
+			ephyrWindowLinear))
+	goto bail4;
+    }
+  else
+    {
+      /* Without shadow fb ( non rotated ) we need 
+       * to use damage to efficiently update display
+       * via signal regions what to copy from 'fb'.
+       */
+      if (!ephyrSetInternalDamage(screen->pScreen))
+	goto bail4;
+    }
+  
+  ephyrSetScreenSizes (screen->pScreen);
+  
+  /*
+   * Set frame buffer mapping
+   */
+  (*pScreen->ModifyPixmapHeader) (fbGetScreenPixmap (pScreen),
+				  pScreen->width,
+				  pScreen->height,
+				  screen->fb.depth,
+				  screen->fb.bitsPerPixel,
+				  screen->fb.byteStride,
+				  screen->fb.frameBuffer);
+  
+  /* set the subpixel order */
+  
+  KdSetSubpixelOrder (pScreen, scrpriv->randr);
+  
+  if (wasEnabled)
+    KdEnableScreen (pScreen);
+  
+  return TRUE;
+  
+ bail4:
+  EPHYR_LOG("bailed");
+  
+  ephyrUnmapFramebuffer (screen);
+  *scrpriv = oldscr;
+  (void) ephyrMapFramebuffer (screen);
+  
+  pScreen->width = oldwidth;
+  pScreen->height = oldheight;
+  pScreen->mmWidth = oldmmwidth;
+  pScreen->mmHeight = oldmmheight;
+  
+  if (wasEnabled)
+    KdEnableScreen (pScreen);
+  return FALSE;
+}
+
+Bool
+ephyrRandRInit (ScreenPtr pScreen)
+{
+  rrScrPrivPtr    pScrPriv;
+  
+  if (!RRScreenInit (pScreen))
+    return FALSE;
+  
+  pScrPriv = rrGetScrPriv(pScreen);
+  pScrPriv->rrGetInfo = ephyrRandRGetInfo;
+  pScrPriv->rrSetConfig = ephyrRandRSetConfig;
+  return TRUE;
+}
+#endif
+
+Bool
+ephyrCreateColormap (ColormapPtr pmap)
+{
+  return fbInitializeColormap (pmap);
+}
+
+Bool
+ephyrInitScreen (ScreenPtr pScreen)
+{
+  KdScreenPriv(pScreen);
+  KdScreenInfo	*screen    = pScreenPriv->screen;
+
+  EPHYR_LOG ("pScreen->myNum:%d\n", pScreen->myNum) ;
+  hostx_set_screen_number (screen, pScreen->myNum);
+  hostx_set_win_title (screen, "(ctrl+shift grabs mouse and keyboard)") ;
+  pScreen->CreateColormap = ephyrCreateColormap;
+
+#ifdef XV
+  if (!ephyrNoXV) {
+      if (!ephyrInitVideo (pScreen)) {
+          EPHYR_LOG_ERROR ("failed to initialize xvideo\n") ;
+      } else {
+          EPHYR_LOG ("initialized xvideo okay\n") ;
+      }
+  }
+#endif /*XV*/
+
+#ifdef XF86DRI
+  if (!ephyrNoDRI && !hostx_has_dri ()) {
+      EPHYR_LOG ("host x does not support DRI. Disabling DRI forwarding\n") ;
+      ephyrNoDRI = TRUE ;
+#ifdef GLXEXT
+      noGlxVisualInit = FALSE ;
+#endif
+  }
+  if (!ephyrNoDRI) {
+    ephyrDRIExtensionInit (pScreen) ;
+    ephyrHijackGLXExtension () ;
+  }
+#endif
+
+#ifdef GLXEXT
+  if (ephyrNoDRI) {
+      noGlxVisualInit = FALSE ;
+  }
+#endif
+
+  return TRUE;
+}
+
+Bool
+ephyrFinishInitScreen (ScreenPtr pScreen)
+{
+  /* FIXME: Calling this even if not using shadow.  
+   * Seems harmless enough. But may be safer elsewhere.
+   */
+  if (!shadowSetup (pScreen))
+    return FALSE;
+
+#ifdef RANDR
+  if (!ephyrRandRInit (pScreen))
+    return FALSE;
+#endif
+
+  return TRUE;
+}
+
+Bool
+ephyrCreateResources (ScreenPtr pScreen)
+{
+  KdScreenPriv(pScreen);
+  KdScreenInfo	*screen    = pScreenPriv->screen;
+  EphyrScrPriv	*scrpriv   = screen->driver;
+
+  EPHYR_LOG("mark pScreen=%p mynum=%d shadow=%d",
+            pScreen, pScreen->myNum, scrpriv->shadow);
+
+  if (scrpriv->shadow) 
+    return KdShadowSet (pScreen, 
+			scrpriv->randr, 
+			ephyrShadowUpdate, 
+			ephyrWindowLinear);
+  else
+    return ephyrSetInternalDamage(pScreen); 
+}
+
+void
+ephyrPreserve (KdCardInfo *card)
+{
+}
+
+Bool
+ephyrEnable (ScreenPtr pScreen)
+{
+  return TRUE;
+}
+
+Bool
+ephyrDPMS (ScreenPtr pScreen, int mode)
+{
+  return TRUE;
+}
+
+void
+ephyrDisable (ScreenPtr pScreen)
+{
+}
+
+void
+ephyrRestore (KdCardInfo *card)
+{
+}
+
+void
+ephyrScreenFini (KdScreenInfo *screen)
+{
+    EphyrScrPriv  *scrpriv = screen->driver;
+    if (scrpriv->shadow) {
+        KdShadowFbFree (screen);
+    }
+    free(screen->driver);
+    screen->driver = NULL;
+}
+
+/*  
+ * Port of Mark McLoughlin's Xnest fix for focus in + modifier bug.
+ * See https://bugs.freedesktop.org/show_bug.cgi?id=3030
+ */
+void
+ephyrUpdateModifierState(unsigned int state)
+{
+
+  DeviceIntPtr pDev = inputInfo.keyboard;
+  KeyClassPtr keyc = pDev->key;
+  int i;
+  CARD8 mask;
+  int xkb_state;
+  
+  if (!pDev)
+      return;
+
+  xkb_state = XkbStateFieldFromRec(&pDev->key->xkbInfo->state);
+  state = state & 0xff;
+
+  if (xkb_state == state)
+    return;
+      
+  for (i = 0, mask = 1; i < 8; i++, mask <<= 1) {
+    int key;
+
+    /* Modifier is down, but shouldn't be
+     */
+    if ((xkb_state & mask) && !(state & mask)) {
+      int count = keyc->modifierKeyCount[i];
+
+      for (key = 0; key < MAP_LENGTH; key++)
+        if (keyc->xkbInfo->desc->map->modmap[key] & mask) {
+          if (key_is_down(pDev, key, KEY_PROCESSED))
+	        KdEnqueueKeyboardEvent (ephyrKbd, key, TRUE);
+
+          if (--count == 0)
+            break;
+        }
+    }
+
+    /* Modifier shoud be down, but isn't
+     */
+    if (!(xkb_state & mask) && (state & mask))
+      for (key = 0; key < MAP_LENGTH; key++)
+        if (keyc->xkbInfo->desc->map->modmap[key] & mask) {
+	        KdEnqueueKeyboardEvent (ephyrKbd, key, FALSE);
+          break;
+        }
+  }
+}
+
+static void
+ephyrBlockSigio (void)
+{
+#ifdef _MSC_VER
+    __asm int 3;
+#else
+    sigset_t set;
+
+    sigemptyset (&set);
+    sigaddset (&set, SIGIO);
+    sigprocmask (SIG_BLOCK, &set, 0);
+#endif
+}
+
+static void
+ephyrUnblockSigio (void)
+{
+#ifdef _MSC_VER
+    __asm int 3;
+#else
+    sigset_t set;
+
+    sigemptyset (&set);
+    sigaddset (&set, SIGIO);
+    sigprocmask (SIG_UNBLOCK, &set, 0);
+#endif
+}
+
+static Bool
+ephyrCursorOffScreen(ScreenPtr *ppScreen, int *x, int *y)
+{
+  return FALSE;
+}
+
+static void
+ephyrCrossScreen (ScreenPtr pScreen, Bool entering)
+{
+}
+
+int ephyrCurScreen; /*current event screen*/
+
+static void
+ephyrWarpCursor (DeviceIntPtr pDev, ScreenPtr pScreen, int x, int y)
+{
+    ephyrBlockSigio ();
+    ephyrCurScreen = pScreen->myNum;
+    miPointerWarpCursor (inputInfo.pointer, pScreen, x, y);
+    ephyrUnblockSigio ();
+}
+
+miPointerScreenFuncRec ephyrPointerScreenFuncs =
+{
+  ephyrCursorOffScreen,
+  ephyrCrossScreen,
+  ephyrWarpCursor,
+  NULL,
+  NULL
+};
+
+#ifdef XF86DRI
+/**
+ * find if the remote window denoted by a_remote
+ * is paired with an internal Window within the Xephyr server.
+ * If the remove window is paired with an internal window, send an
+ * expose event to the client insterested in the internal window expose event.
+ *
+ * Pairing happens when a drawable inside Xephyr is associated with
+ * a GL surface in a DRI environment.
+ * Look at the function ProcXF86DRICreateDrawable in ephyrdriext.c to
+ * know a paired window is created.
+ *
+ * This is useful to make GL drawables (only windows for now) handle
+ * expose events and send those events to clients.
+ */
+static void
+ephyrExposePairedWindow (int a_remote)
+{
+    EphyrWindowPair *pair = NULL;
+    RegionRec reg;
+    ScreenPtr screen;
+
+    if (!findWindowPairFromRemote (a_remote, &pair)) {
+	EPHYR_LOG ("did not find a pair for this window\n");
+	return;
+    }
+    screen = pair->local->drawable.pScreen;
+    RegionNull(&reg);
+    RegionCopy(&reg, &pair->local->clipList);
+    screen->WindowExposures (pair->local, &reg, NullRegion);
+    RegionUninit(&reg);
+}
+#endif /* XF86DRI */
+
+void
+ephyrPoll(void)
+{
+  EphyrHostXEvent ev;
+
+  while (hostx_get_event(&ev))
+    {
+      switch (ev.type)
+        {
+        case EPHYR_EV_MOUSE_MOTION:
+          if (!ephyrMouse ||
+              !((EphyrPointerPrivate *)ephyrMouse->driverPrivate)->enabled) {
+              EPHYR_LOG ("skipping mouse motion:%d\n", ephyrCurScreen) ;
+              continue;
+          }
+          {
+            if (ev.data.mouse_motion.screen >=0
+                && (ephyrCurScreen != ev.data.mouse_motion.screen))
+              {
+                  EPHYR_LOG ("warping mouse cursor. "
+                             "cur_screen%d, motion_screen:%d\n",
+                             ephyrCurScreen, ev.data.mouse_motion.screen) ;
+                  if (ev.data.mouse_motion.screen >= 0)
+                    {
+                      ephyrWarpCursor
+                            (inputInfo.pointer, screenInfo.screens[ev.data.mouse_motion.screen],
+                             ev.data.mouse_motion.x,
+                             ev.data.mouse_motion.y );
+                    }
+              }
+            else
+              {
+                  int x=0, y=0;
+#ifdef XF86DRI
+                  EphyrWindowPair *pair = NULL;
+#endif
+                  EPHYR_LOG ("enqueuing mouse motion:%d\n", ephyrCurScreen) ;
+                  x = ev.data.mouse_motion.x;
+                  y = ev.data.mouse_motion.y;
+                  EPHYR_LOG ("initial (x,y):(%d,%d)\n", x, y) ;
+#ifdef XF86DRI
+                  EPHYR_LOG ("is this window peered by a gl drawable ?\n") ;
+                  if (findWindowPairFromRemote (ev.data.mouse_motion.window,
+                                                &pair))
+                    {
+                        EPHYR_LOG ("yes, it is peered\n") ;
+                        x += pair->local->drawable.x;
+                        y += pair->local->drawable.y;
+                    }
+                  else
+                    {
+                        EPHYR_LOG ("no, it is not peered\n") ;
+                    }
+                  EPHYR_LOG ("final (x,y):(%d,%d)\n", x, y) ;
+#endif
+                  KdEnqueuePointerEvent(ephyrMouse, mouseState, x, y, 0);
+              }
+          }
+          break;
+
+        case EPHYR_EV_MOUSE_PRESS:
+          if (!ephyrMouse ||
+              !((EphyrPointerPrivate *)ephyrMouse->driverPrivate)->enabled) {
+              EPHYR_LOG ("skipping mouse press:%d\n", ephyrCurScreen) ;
+              continue;
+          }
+          EPHYR_LOG ("enqueuing mouse press:%d\n", ephyrCurScreen) ;
+	  ephyrUpdateModifierState(ev.key_state);
+	  mouseState |= ev.data.mouse_down.button_num;
+	  KdEnqueuePointerEvent(ephyrMouse, mouseState|KD_MOUSE_DELTA, 0, 0, 0);
+	  break;
+
+	case EPHYR_EV_MOUSE_RELEASE:
+          if (!ephyrMouse ||
+              !((EphyrPointerPrivate *)ephyrMouse->driverPrivate)->enabled)
+              continue;
+	  ephyrUpdateModifierState(ev.key_state);
+	  mouseState &= ~ev.data.mouse_up.button_num;
+          EPHYR_LOG ("enqueuing mouse release:%d\n", ephyrCurScreen) ;
+	  KdEnqueuePointerEvent(ephyrMouse, mouseState|KD_MOUSE_DELTA, 0, 0, 0);
+	  break;
+
+	case EPHYR_EV_KEY_PRESS:
+          if (!ephyrKbd ||
+              !((EphyrKbdPrivate *)ephyrKbd->driverPrivate)->enabled)
+              continue;
+	  ephyrUpdateModifierState(ev.key_state);
+	  KdEnqueueKeyboardEvent (ephyrKbd, ev.data.key_down.scancode, FALSE);
+	  break;
+
+	case EPHYR_EV_KEY_RELEASE:
+          if (!ephyrKbd ||
+              !((EphyrKbdPrivate *)ephyrKbd->driverPrivate)->enabled)
+              continue;
+	  ephyrUpdateModifierState(ev.key_state);
+	  KdEnqueueKeyboardEvent (ephyrKbd, ev.data.key_up.scancode, TRUE);
+	  break;
+
+#ifdef XF86DRI
+	case EPHYR_EV_EXPOSE:
+	  /*
+	   * We only receive expose events when the expose event have
+	   * be generated for a drawable that is a host X window managed
+	   * by Xephyr. Host X windows managed by Xephyr exists for instance
+	   * when Xephyr is asked to create a GL drawable in a DRI environment.
+	   */
+	  ephyrExposePairedWindow (ev.data.expose.window);
+	  break;
+#endif /* XF86DRI */
+
+	default:
+	  break;
+	}
+    }
+}
+
+void
+ephyrCardFini (KdCardInfo *card)
+{
+  EphyrPriv	*priv = card->driver;
+  free(priv);
+}
+
+void
+ephyrGetColors (ScreenPtr pScreen, int n, xColorItem *pdefs)
+{
+  /* XXX Not sure if this is right */
+  
+  EPHYR_LOG("mark");
+  
+  while (n--)
+    {
+      pdefs->red = 0;
+      pdefs->green = 0;
+      pdefs->blue = 0;
+      pdefs++;
+    }
+
+}
+
+void
+ephyrPutColors (ScreenPtr pScreen, int n, xColorItem *pdefs)
+{
+  int min, max, p;
+
+  /* XXX Not sure if this is right */
+
+  min = 256;
+  max = 0;
+  
+  while (n--)
+    {
+      p = pdefs->pixel;
+      if (p < min)
+	min = p;
+      if (p > max)
+	max = p;
+
+      hostx_set_cmap_entry(p, 		
+			   pdefs->red >> 8,
+			   pdefs->green >> 8,
+			   pdefs->blue >> 8);
+      pdefs++;
+    }
+}
+
+/* Mouse calls */
+
+static Status
+MouseInit (KdPointerInfo *pi)
+{
+    pi->driverPrivate = (EphyrPointerPrivate *)
+                         calloc(sizeof(EphyrPointerPrivate), 1);
+    ((EphyrPointerPrivate *)pi->driverPrivate)->enabled = FALSE;
+    pi->nAxes = 3;
+    pi->nButtons = 32;
+    free(pi->name);
+    pi->name = strdup("Xephyr virtual mouse");
+
+    /*
+     * Must transform pointer coords since the pointer position
+     * relative to the Xephyr window is controlled by the host server and
+     * remains constant regardless of any rotation applied to the Xephyr screen.
+     */
+    pi->transformCoordinates = TRUE;
+
+    ephyrMouse = pi;
+    return Success;
+}
+
+static Status
+MouseEnable (KdPointerInfo *pi)
+{
+    ((EphyrPointerPrivate *)pi->driverPrivate)->enabled = TRUE;
+    return Success;
+}
+
+static void
+MouseDisable (KdPointerInfo *pi)
+{
+    ((EphyrPointerPrivate *)pi->driverPrivate)->enabled = FALSE;
+    return;
+}
+
+static void
+MouseFini (KdPointerInfo *pi)
+{
+    ephyrMouse = NULL; 
+    return;
+}
+
+KdPointerDriver EphyrMouseDriver = {
+    "ephyr",
+    MouseInit,
+    MouseEnable,
+    MouseDisable,
+    MouseFini,
+    NULL,
+};
+
+/* Keyboard */
+
+static Status
+EphyrKeyboardInit (KdKeyboardInfo *ki)
+{
+  ki->driverPrivate = (EphyrKbdPrivate *)
+                       calloc(sizeof(EphyrKbdPrivate), 1);
+  hostx_load_keymap();
+  if (!ephyrKeySyms.map) {
+      ErrorF("Couldn't load keymap from host\n");
+      return BadAlloc;
+  }
+  ki->minScanCode = ephyrKeySyms.minKeyCode;
+  ki->maxScanCode = ephyrKeySyms.maxKeyCode;
+  free(ki->name);
+  ki->name = strdup("Xephyr virtual keyboard");
+  ephyrKbd = ki;
+  return Success;
+}
+
+static Status
+EphyrKeyboardEnable (KdKeyboardInfo *ki)
+{
+    ((EphyrKbdPrivate *)ki->driverPrivate)->enabled = TRUE;
+
+    return Success;
+}
+
+static void
+EphyrKeyboardDisable (KdKeyboardInfo *ki)
+{
+    ((EphyrKbdPrivate *)ki->driverPrivate)->enabled = FALSE;
+}
+
+static void
+EphyrKeyboardFini (KdKeyboardInfo *ki)
+{
+    ephyrKbd = NULL;
+    return;
+}
+
+static void
+EphyrKeyboardLeds (KdKeyboardInfo *ki, int leds)
+{
+}
+
+static void
+EphyrKeyboardBell (KdKeyboardInfo *ki, int volume, int frequency, int duration)
+{
+}
+
+
+KdKeyboardDriver EphyrKeyboardDriver = {
+    "ephyr",
+    EphyrKeyboardInit,
+    EphyrKeyboardEnable,
+    EphyrKeyboardLeds,
+    EphyrKeyboardBell,
+    EphyrKeyboardDisable,
+    EphyrKeyboardFini,
+    NULL,
+};
diff --git a/xorg-server/hw/kdrive/ephyr/ephyr.h b/xorg-server/hw/kdrive/ephyr/ephyr.h
index 6ec8eb609..73ebcfa5b 100644
--- a/xorg-server/hw/kdrive/ephyr/ephyr.h
+++ b/xorg-server/hw/kdrive/ephyr/ephyr.h
@@ -1,207 +1,207 @@
-/*

- * Xephyr - A kdrive X server thats runs in a host X window.

- *          Authored by Matthew Allum <mallum@o-hand.com>

- * 

- * Copyright © 2004 Nokia 

- *

- * 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 Nokia not be used in

- * advertising or publicity pertaining to distribution of the software without

- * specific, written prior permission. Nokia makes no

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

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

- *

- * NOKIA DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,

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

- * EVENT SHALL NOKIA 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.

- */

-

-#ifndef _EPHYR_H_

-#define _EPHYR_H_

-#include <stdio.h>

-#ifndef _MSC_VER

-#include <unistd.h>

-#include <libgen.h>

-#endif

-#include <signal.h>

-

-#include "os.h"  		/* for OsSignal() */

-#include "kdrive.h"

-#include "hostx.h"

-#include "exa.h"

-

-#ifdef RANDR

-#include "randrstr.h"

-#endif

-

-#include "damage.h"

-

-typedef struct _ephyrPriv {

-    CARD8	*base;

-    int		bytes_per_line;

-} EphyrPriv;

-

-typedef struct _ephyrFakexaPriv {

-    ExaDriverPtr exa;

-    Bool is_synced;

-

-    /* The following are arguments and other information from Prepare* calls

-     * which are stored for use in the inner calls.

-     */

-    int op;

-    PicturePtr pSrcPicture, pMaskPicture, pDstPicture;

-    void *saved_ptrs[3];

-    PixmapPtr pDst, pSrc, pMask;

-    GCPtr pGC;

-} EphyrFakexaPriv;

-

-typedef struct _ephyrScrPriv {

-    Rotation	randr;

-    Bool	shadow;

-    DamagePtr   pDamage;

-    EphyrFakexaPriv *fakexa;

-} EphyrScrPriv;

-

-extern KdCardFuncs ephyrFuncs;

-extern KdKeyboardInfo *ephyrKbd;

-extern KdPointerInfo *ephyrMouse;

-

-extern miPointerScreenFuncRec ephyrPointerScreenFuncs;

-

-Bool

-ephyrInitialize (KdCardInfo *card, EphyrPriv *priv);

-

-Bool

-ephyrCardInit (KdCardInfo *card);

-

-Bool

-ephyrScreenInit (KdScreenInfo *screen);

-

-Bool

-ephyrScreenInitialize (KdScreenInfo *screen, EphyrScrPriv *scrpriv);

-    

-Bool

-ephyrInitScreen (ScreenPtr pScreen);

-

-Bool

-ephyrFinishInitScreen (ScreenPtr pScreen);

-

-Bool

-ephyrCreateResources (ScreenPtr pScreen);

-

-void

-ephyrPreserve (KdCardInfo *card);

-

-Bool

-ephyrEnable (ScreenPtr pScreen);

-

-Bool

-ephyrDPMS (ScreenPtr pScreen, int mode);

-

-void

-ephyrDisable (ScreenPtr pScreen);

-

-void

-ephyrRestore (KdCardInfo *card);

-

-void

-ephyrScreenFini (KdScreenInfo *screen);

-

-void

-ephyrCardFini (KdCardInfo *card);

-

-void

-ephyrGetColors (ScreenPtr pScreen, int n, xColorItem *pdefs);

-

-void

-ephyrPutColors (ScreenPtr pScreen, int n, xColorItem *pdefs);

-

-Bool

-ephyrMapFramebuffer (KdScreenInfo *screen);

-

-void *

-ephyrWindowLinear (ScreenPtr	pScreen,

-		   CARD32	row,

-		   CARD32	offset,

-		   int		mode,

-		   CARD32	*size,

-		   void		*closure);

-

-void

-ephyrSetScreenSizes (ScreenPtr pScreen);

-

-Bool

-ephyrUnmapFramebuffer (KdScreenInfo *screen);

-

-void

-ephyrUnsetInternalDamage (ScreenPtr pScreen);

-

-Bool

-ephyrSetInternalDamage (ScreenPtr pScreen);

-

-Bool

-ephyrCreateColormap (ColormapPtr pmap);

-

-void

-ephyrPoll(void);

-    

-#ifdef RANDR

-Bool

-ephyrRandRGetInfo (ScreenPtr pScreen, Rotation *rotations);

-

-Bool

-ephyrRandRSetConfig (ScreenPtr		pScreen,

-		     Rotation		randr,

-		     int		rate,

-		     RRScreenSizePtr	pSize);

-Bool

-ephyrRandRInit (ScreenPtr pScreen);

-

-void 

-ephyrShadowUpdate (ScreenPtr pScreen, shadowBufPtr pBuf);

-

-#endif

-

-void

-ephyrUpdateModifierState(unsigned int state);

-

-extern KdPointerDriver EphyrMouseDriver;

-

-extern KdKeyboardDriver	EphyrKeyboardDriver;

-

-extern KdOsFuncs   EphyrOsFuncs;

-

-extern Bool ephyrCursorInit(ScreenPtr pScreen);

-

-extern void ephyrCursorEnable(ScreenPtr pScreen);

-

-extern int ephyrBufferHeight(KdScreenInfo *screen);

-

-extern int ephyrBufferHeight(KdScreenInfo *screen);

-

-/* ephyr_draw.c */

-

-Bool

-ephyrDrawInit(ScreenPtr pScreen);

-

-void

-ephyrDrawEnable(ScreenPtr pScreen);

-

-void

-ephyrDrawDisable(ScreenPtr pScreen);

-

-void

-ephyrDrawFini(ScreenPtr pScreen);

-

-/*ephyvideo.c*/

-

-Bool ephyrInitVideo(ScreenPtr pScreen) ;

-

-#endif

+/*
+ * Xephyr - A kdrive X server thats runs in a host X window.
+ *          Authored by Matthew Allum <mallum@o-hand.com>
+ * 
+ * Copyright © 2004 Nokia 
+ *
+ * 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 Nokia not be used in
+ * advertising or publicity pertaining to distribution of the software without
+ * specific, written prior permission. Nokia makes no
+ * representations about the suitability of this software for any purpose.  It
+ * is provided "as is" without express or implied warranty.
+ *
+ * NOKIA DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
+ * EVENT SHALL NOKIA 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.
+ */
+
+#ifndef _EPHYR_H_
+#define _EPHYR_H_
+#include <stdio.h>
+#ifndef _MSC_VER
+#include <unistd.h>
+#include <libgen.h>
+#endif
+#include <signal.h>
+
+#include "os.h"  		/* for OsSignal() */
+#include "kdrive.h"
+#include "hostx.h"
+#include "exa.h"
+
+#ifdef RANDR
+#include "randrstr.h"
+#endif
+
+#include "damage.h"
+
+typedef struct _ephyrPriv {
+    CARD8	*base;
+    int		bytes_per_line;
+} EphyrPriv;
+
+typedef struct _ephyrFakexaPriv {
+    ExaDriverPtr exa;
+    Bool is_synced;
+
+    /* The following are arguments and other information from Prepare* calls
+     * which are stored for use in the inner calls.
+     */
+    int op;
+    PicturePtr pSrcPicture, pMaskPicture, pDstPicture;
+    void *saved_ptrs[3];
+    PixmapPtr pDst, pSrc, pMask;
+    GCPtr pGC;
+} EphyrFakexaPriv;
+
+typedef struct _ephyrScrPriv {
+    Rotation	randr;
+    Bool	shadow;
+    DamagePtr   pDamage;
+    EphyrFakexaPriv *fakexa;
+} EphyrScrPriv;
+
+extern KdCardFuncs ephyrFuncs;
+extern KdKeyboardInfo *ephyrKbd;
+extern KdPointerInfo *ephyrMouse;
+
+extern miPointerScreenFuncRec ephyrPointerScreenFuncs;
+
+Bool
+ephyrInitialize (KdCardInfo *card, EphyrPriv *priv);
+
+Bool
+ephyrCardInit (KdCardInfo *card);
+
+Bool
+ephyrScreenInit (KdScreenInfo *screen);
+
+Bool
+ephyrScreenInitialize (KdScreenInfo *screen, EphyrScrPriv *scrpriv);
+    
+Bool
+ephyrInitScreen (ScreenPtr pScreen);
+
+Bool
+ephyrFinishInitScreen (ScreenPtr pScreen);
+
+Bool
+ephyrCreateResources (ScreenPtr pScreen);
+
+void
+ephyrPreserve (KdCardInfo *card);
+
+Bool
+ephyrEnable (ScreenPtr pScreen);
+
+Bool
+ephyrDPMS (ScreenPtr pScreen, int mode);
+
+void
+ephyrDisable (ScreenPtr pScreen);
+
+void
+ephyrRestore (KdCardInfo *card);
+
+void
+ephyrScreenFini (KdScreenInfo *screen);
+
+void
+ephyrCardFini (KdCardInfo *card);
+
+void
+ephyrGetColors (ScreenPtr pScreen, int n, xColorItem *pdefs);
+
+void
+ephyrPutColors (ScreenPtr pScreen, int n, xColorItem *pdefs);
+
+Bool
+ephyrMapFramebuffer (KdScreenInfo *screen);
+
+void *
+ephyrWindowLinear (ScreenPtr	pScreen,
+		   CARD32	row,
+		   CARD32	offset,
+		   int		mode,
+		   CARD32	*size,
+		   void		*closure);
+
+void
+ephyrSetScreenSizes (ScreenPtr pScreen);
+
+Bool
+ephyrUnmapFramebuffer (KdScreenInfo *screen);
+
+void
+ephyrUnsetInternalDamage (ScreenPtr pScreen);
+
+Bool
+ephyrSetInternalDamage (ScreenPtr pScreen);
+
+Bool
+ephyrCreateColormap (ColormapPtr pmap);
+
+void
+ephyrPoll(void);
+    
+#ifdef RANDR
+Bool
+ephyrRandRGetInfo (ScreenPtr pScreen, Rotation *rotations);
+
+Bool
+ephyrRandRSetConfig (ScreenPtr		pScreen,
+		     Rotation		randr,
+		     int		rate,
+		     RRScreenSizePtr	pSize);
+Bool
+ephyrRandRInit (ScreenPtr pScreen);
+
+void 
+ephyrShadowUpdate (ScreenPtr pScreen, shadowBufPtr pBuf);
+
+#endif
+
+void
+ephyrUpdateModifierState(unsigned int state);
+
+extern KdPointerDriver EphyrMouseDriver;
+
+extern KdKeyboardDriver	EphyrKeyboardDriver;
+
+extern KdOsFuncs   EphyrOsFuncs;
+
+extern Bool ephyrCursorInit(ScreenPtr pScreen);
+
+extern void ephyrCursorEnable(ScreenPtr pScreen);
+
+extern int ephyrBufferHeight(KdScreenInfo *screen);
+
+extern int ephyrBufferHeight(KdScreenInfo *screen);
+
+/* ephyr_draw.c */
+
+Bool
+ephyrDrawInit(ScreenPtr pScreen);
+
+void
+ephyrDrawEnable(ScreenPtr pScreen);
+
+void
+ephyrDrawDisable(ScreenPtr pScreen);
+
+void
+ephyrDrawFini(ScreenPtr pScreen);
+
+/*ephyvideo.c*/
+
+Bool ephyrInitVideo(ScreenPtr pScreen) ;
+
+#endif
diff --git a/xorg-server/hw/kdrive/ephyr/ephyrinit.c b/xorg-server/hw/kdrive/ephyr/ephyrinit.c
index 1056172ae..8160d8414 100644
--- a/xorg-server/hw/kdrive/ephyr/ephyrinit.c
+++ b/xorg-server/hw/kdrive/ephyr/ephyrinit.c
@@ -1,433 +1,433 @@
-/*

- * Xephyr - A kdrive X server thats runs in a host X window.

- *          Authored by Matthew Allum <mallum@o-hand.com>

- * 

- * Copyright © 2004 Nokia 

- *

- * 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 Nokia not be used in

- * advertising or publicity pertaining to distribution of the software without

- * specific, written prior permission. Nokia makes no

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

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

- *

- * NOKIA DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,

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

- * EVENT SHALL NOKIA 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_CONFIG_H

-#include <kdrive-config.h>

-#endif

-#include "ephyr.h"

-#include "ephyrlog.h"

-

-extern Window EphyrPreExistingHostWin;

-extern Bool   EphyrWantGrayScale;

-extern Bool   kdHasPointer;

-extern Bool   kdHasKbd;

-

-#ifdef GLXEXT

-extern Bool   ephyrNoDRI;

-extern Bool noGlxVisualInit;

-#endif

-extern Bool   ephyrNoXV;

-

-#ifdef KDRIVE_EVDEV

-extern KdPointerDriver	LinuxEvdevMouseDriver;

-extern KdKeyboardDriver LinuxEvdevKeyboardDriver;

-#endif

-

-void processScreenArg (char *screen_size, char *parent_id) ;

-

-void

-InitCard (char *name)

-{

-    EPHYR_DBG("mark");

-    KdCardInfoAdd (&ephyrFuncs, 0);

-}

-

-#ifndef _MSC_VER

-void

-InitOutput (ScreenInfo *pScreenInfo, int argc, char **argv)

-{

-  KdInitOutput (pScreenInfo, argc, argv);

-}

-

-void

-InitInput (int argc, char **argv)

-{

-  KdKeyboardInfo *ki;

-  KdPointerInfo *pi;

-

-  KdAddKeyboardDriver(&EphyrKeyboardDriver);

-#ifdef KDRIVE_EVDEV

-  KdAddKeyboardDriver(&LinuxEvdevKeyboardDriver);

-#endif

-  KdAddPointerDriver(&EphyrMouseDriver);

-#ifdef KDRIVE_EVDEV

-  KdAddPointerDriver(&LinuxEvdevMouseDriver);

-#endif

-

-  if (!kdHasKbd) {

-    ki = KdNewKeyboard();

-    if (!ki)

-      FatalError("Couldn't create Xephyr keyboard\n");

-    ki->driver = &EphyrKeyboardDriver;

-    KdAddKeyboard(ki);

-  }

-

-  if (!kdHasPointer) {

-    pi = KdNewPointer();

-    if (!pi)

-      FatalError("Couldn't create Xephyr pointer\n");

-    pi->driver = &EphyrMouseDriver;

-    KdAddPointer(pi);

-  }

-

-  KdInitInput();

-}

-

-void

-CloseInput (void)

-{

-  KdCloseInput();

-}

-

-#ifdef DDXBEFORERESET

-void

-ddxBeforeReset (void)

-{

-}

-#endif

-

-void

-ddxUseMsg (void)

-{

-  KdUseMsg();

-

-  ErrorF("\nXephyr Option Usage:\n");

-  ErrorF("-parent <XID>        Use existing window as Xephyr root win\n");

-  ErrorF("-host-cursor         Re-use exisiting X host server cursor\n");

-  ErrorF("-fullscreen          Attempt to run Xephyr fullscreen\n");

-  ErrorF("-grayscale           Simulate 8bit grayscale\n");

-  ErrorF("-fakexa              Simulate acceleration using software rendering\n");

-  ErrorF("-verbosity <level>   Set log verbosity level\n");

-#ifdef GLXEXT

-  ErrorF("-nodri               do not use DRI\n");

-#endif

-  ErrorF("-noxv                do not use XV\n");

-  ErrorF("-name [name]         define the name in the WM_CLASS property\n");

-  ErrorF("-title [title]       set the window title in the WM_NAME property\n");

-  ErrorF("\n");

-

-  exit(1);

-}

-#endif

-

-void

-processScreenArg (char *screen_size, char *parent_id)

-{

-  KdCardInfo   *card;

-

-  InitCard (0);  /*Put each screen on a separate card*/

-  card = KdCardInfoLast ();

-

-  if (card)

-    {

-      KdScreenInfo *screen;

-      unsigned long p_id = 0;

-

-      screen = KdScreenInfoAdd (card);

-      KdParseScreen (screen, screen_size);

-

-      if (parent_id)

-        {

-          p_id = strtol (parent_id, NULL, 0);

-        }

-      EPHYR_DBG ("screen number:%d\n", screen->mynum) ;

-      hostx_add_screen (screen, p_id, screen->mynum);

-    }

-  else

-    {

-      ErrorF("No matching card found!\n");

-    }

-}

-

-#ifndef _MSC_VER

-int

-ddxProcessArgument (int argc, char **argv, int i)

-{

-  static char* parent = NULL;

-  EPHYR_DBG("mark argv[%d]='%s'", i, argv[i] );

-

-  if (i == 1)

-    {

-      hostx_use_resname(basename(argv[0]), 0);

-    }

-

-  if (!strcmp (argv[i], "-parent"))

-    {

-      if(i+1 < argc)

-	{

-	  int j;

-	  /* If parent is specified and a screen argument follows, don't do

-           * anything, let the -screen handling init the rest */

-	  for (j = i; j < argc; j++)

-	    {

-	      if (!strcmp(argv[j], "-screen"))

-		{

-		  parent = argv[i + 1];

-		  return 2;

-		}

-	    }

-

-	  processScreenArg ("100x100", argv[i+1]);

-	  return 2;

-	}

-

-      UseMsg();

-      exit(1);

-    }

-  else if (!strcmp (argv[i], "-screen"))

-    {

-      if ((i+1) < argc)

-	{

-	  processScreenArg (argv[i+1], parent);

-	  parent = NULL;

-	  return 2;

-	}

-

-      UseMsg();

-      exit(1);

-    }

-  else if (!strcmp (argv[i], "-host-cursor"))

-    {

-      hostx_use_host_cursor();

-      return 1;

-    }

-  else if (!strcmp (argv[i], "-fullscreen"))

-    {

-      hostx_use_fullscreen();

-      return 1;

-    }

-  else if (!strcmp (argv[i], "-grayscale"))

-    {

-      EphyrWantGrayScale = 1;      

-      return 1;

-    }

-  else if (!strcmp (argv[i], "-fakexa"))

-    {

-      ephyrFuncs.initAccel = ephyrDrawInit;

-      ephyrFuncs.enableAccel = ephyrDrawEnable;

-      ephyrFuncs.disableAccel = ephyrDrawDisable;

-      ephyrFuncs.finiAccel = ephyrDrawFini;

-      return 1;

-    }

-  else if (!strcmp (argv[i], "-verbosity"))

-    {

-      if(i+1 < argc && argv[i+1][0] != '-')

-	{

-	  int verbosity=atoi (argv[i+1]) ;

-	  LogSetParameter (XLOG_VERBOSITY, verbosity) ;

-	  EPHYR_LOG ("set verbosiry to %d\n", verbosity) ;

-	  return 2 ;

-	}

-      else

-	{

-	  UseMsg() ;

-	  exit(1) ;

-	}

-    }

-#ifdef GLXEXT

-  else if (!strcmp (argv[i], "-nodri"))

-   {

-       noGlxVisualInit = FALSE ;

-       ephyrNoDRI = TRUE ;

-       EPHYR_LOG ("no direct rendering enabled\n") ;

-       return 1 ;

-   }

-#endif

-  else if (!strcmp (argv[i], "-noxv"))

-   {

-       ephyrNoXV = TRUE ;

-       EPHYR_LOG ("no XVideo enabled\n") ;

-       return 1 ;

-   }

-  else if (!strcmp (argv[i], "-name"))

-   {

-       if (i+1 < argc && argv[i+1][0] != '-')

-         {

-           hostx_use_resname(argv[i+1], 1);

-           return 2;

-         }

-       else

-         {

-           UseMsg();

-           return 0;

-         }

-   }

-  else if (!strcmp (argv[i], "-title"))

-   {

-       if (i+1 < argc && argv[i+1][0] != '-')

-         {

-           hostx_set_title(argv[i+1]);

-           return 2;

-         }

-       else

-         {

-           UseMsg();

-           return 0;

-         }

-   }

-  else if (argv[i][0] == ':')

-    {

-      hostx_set_display_name(argv[i]);

-    }

-  /* Xnest compatibility */

-  else if (!strcmp(argv[i], "-display"))

-  {

-      hostx_set_display_name(argv[i+1]);

-      return 2;

-  }

-  else if (!strcmp(argv[i], "-sync") ||

-	   !strcmp(argv[i], "-full") ||

-	   !strcmp(argv[i], "-sss") ||

-	   !strcmp(argv[i], "-install"))

-  {

-      return 1;

-  }

-  else if (!strcmp(argv[i], "-bw") ||

-	   !strcmp(argv[i], "-class") ||

-	   !strcmp(argv[i], "-geometry") ||

-	   !strcmp(argv[i], "-scrns"))

-  {

-      return 2;

-  }

-  /* end Xnest compat */

-

-  return KdProcessArgument (argc, argv, i);

-}

-

-void

-OsVendorInit (void)

-{

-  EPHYR_DBG("mark");

-

-  if (hostx_want_host_cursor())

-    {

-      ephyrFuncs.initCursor   = &ephyrCursorInit;

-      ephyrFuncs.enableCursor = &ephyrCursorEnable;

-    }

-

-  KdOsInit (&EphyrOsFuncs);

-}

-

-#ifdef DDXOSFATALERROR

-void

-OsVendorFatalError(void)

-{

-}

-#endif

-

-#endif

-

-/* 'Fake' cursor stuff, could be improved */

-

-static Bool

-ephyrRealizeCursor(DeviceIntPtr pDev, ScreenPtr pScreen, CursorPtr pCursor)

-{

-  return TRUE;

-}

-

-static Bool

-ephyrUnrealizeCursor(DeviceIntPtr pDev, ScreenPtr pScreen, CursorPtr pCursor)

-{

-  return TRUE;

-}

-

-static void

-ephyrSetCursor(DeviceIntPtr pDev, ScreenPtr pScreen, CursorPtr pCursor, int x, int y)

-{

-  ;

-}

-

-static void

-ephyrMoveCursor(DeviceIntPtr pDev, ScreenPtr pScreen, int x, int y)

-{

-  ;

-}

-

-static Bool

-ephyrDeviceCursorInitialize(DeviceIntPtr pDev, ScreenPtr pScreen)

-{

-  return TRUE;

-}

-

-static void

-ephyrDeviceCursorCleanup(DeviceIntPtr pDev, ScreenPtr pScreen)

-{

-}

-

-miPointerSpriteFuncRec EphyrPointerSpriteFuncs = {

-	ephyrRealizeCursor,

-	ephyrUnrealizeCursor,

-	ephyrSetCursor,

-	ephyrMoveCursor,

-	ephyrDeviceCursorInitialize,

-	ephyrDeviceCursorCleanup

-};

-

-

-Bool

-ephyrCursorInit(ScreenPtr pScreen)

-{

-  miPointerInitialize(pScreen,

-		      &EphyrPointerSpriteFuncs,

-		      &ephyrPointerScreenFuncs,

-		      FALSE);

-

-  return TRUE;

-}

-

-void

-ephyrCursorEnable(ScreenPtr pScreen)

-{

-  ;

-}

-

-KdCardFuncs ephyrFuncs = {

-    ephyrCardInit,	    /* cardinit */

-    ephyrScreenInit,	    /* scrinit */

-    ephyrInitScreen,	    /* initScreen */

-    ephyrFinishInitScreen,  /* finishInitScreen */

-    ephyrCreateResources,   /* createRes */

-    ephyrPreserve,	    /* preserve */

-    ephyrEnable,	    /* enable */

-    ephyrDPMS,		    /* dpms */

-    ephyrDisable,	    /* disable */

-    ephyrRestore,	    /* restore */

-    ephyrScreenFini,	    /* scrfini */

-    ephyrCardFini,	    /* cardfini */

-

-    0,			    /* initCursor */

-    0,			    /* enableCursor */

-    0,			    /* disableCursor */

-    0,			    /* finiCursor */

-    0,			    /* recolorCursor */

-

-    0,			    /* initAccel */

-    0,			    /* enableAccel */

-    0,			    /* disableAccel */

-    0,			    /* finiAccel */

-

-    ephyrGetColors,/* getColors */

-    ephyrPutColors,	    /* putColors */

-};

+/*
+ * Xephyr - A kdrive X server thats runs in a host X window.
+ *          Authored by Matthew Allum <mallum@o-hand.com>
+ * 
+ * Copyright © 2004 Nokia 
+ *
+ * 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 Nokia not be used in
+ * advertising or publicity pertaining to distribution of the software without
+ * specific, written prior permission. Nokia makes no
+ * representations about the suitability of this software for any purpose.  It
+ * is provided "as is" without express or implied warranty.
+ *
+ * NOKIA DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
+ * EVENT SHALL NOKIA 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_CONFIG_H
+#include <kdrive-config.h>
+#endif
+#include "ephyr.h"
+#include "ephyrlog.h"
+
+extern Window EphyrPreExistingHostWin;
+extern Bool   EphyrWantGrayScale;
+extern Bool   kdHasPointer;
+extern Bool   kdHasKbd;
+
+#ifdef GLXEXT
+extern Bool   ephyrNoDRI;
+extern Bool noGlxVisualInit;
+#endif
+extern Bool   ephyrNoXV;
+
+#ifdef KDRIVE_EVDEV
+extern KdPointerDriver	LinuxEvdevMouseDriver;
+extern KdKeyboardDriver LinuxEvdevKeyboardDriver;
+#endif
+
+void processScreenArg (char *screen_size, char *parent_id) ;
+
+void
+InitCard (char *name)
+{
+    EPHYR_DBG("mark");
+    KdCardInfoAdd (&ephyrFuncs, 0);
+}
+
+#ifndef _MSC_VER
+void
+InitOutput (ScreenInfo *pScreenInfo, int argc, char **argv)
+{
+  KdInitOutput (pScreenInfo, argc, argv);
+}
+
+void
+InitInput (int argc, char **argv)
+{
+  KdKeyboardInfo *ki;
+  KdPointerInfo *pi;
+
+  KdAddKeyboardDriver(&EphyrKeyboardDriver);
+#ifdef KDRIVE_EVDEV
+  KdAddKeyboardDriver(&LinuxEvdevKeyboardDriver);
+#endif
+  KdAddPointerDriver(&EphyrMouseDriver);
+#ifdef KDRIVE_EVDEV
+  KdAddPointerDriver(&LinuxEvdevMouseDriver);
+#endif
+
+  if (!kdHasKbd) {
+    ki = KdNewKeyboard();
+    if (!ki)
+      FatalError("Couldn't create Xephyr keyboard\n");
+    ki->driver = &EphyrKeyboardDriver;
+    KdAddKeyboard(ki);
+  }
+
+  if (!kdHasPointer) {
+    pi = KdNewPointer();
+    if (!pi)
+      FatalError("Couldn't create Xephyr pointer\n");
+    pi->driver = &EphyrMouseDriver;
+    KdAddPointer(pi);
+  }
+
+  KdInitInput();
+}
+
+void
+CloseInput (void)
+{
+  KdCloseInput();
+}
+
+#ifdef DDXBEFORERESET
+void
+ddxBeforeReset (void)
+{
+}
+#endif
+
+void
+ddxUseMsg (void)
+{
+  KdUseMsg();
+
+  ErrorF("\nXephyr Option Usage:\n");
+  ErrorF("-parent <XID>        Use existing window as Xephyr root win\n");
+  ErrorF("-host-cursor         Re-use exisiting X host server cursor\n");
+  ErrorF("-fullscreen          Attempt to run Xephyr fullscreen\n");
+  ErrorF("-grayscale           Simulate 8bit grayscale\n");
+  ErrorF("-fakexa              Simulate acceleration using software rendering\n");
+  ErrorF("-verbosity <level>   Set log verbosity level\n");
+#ifdef GLXEXT
+  ErrorF("-nodri               do not use DRI\n");
+#endif
+  ErrorF("-noxv                do not use XV\n");
+  ErrorF("-name [name]         define the name in the WM_CLASS property\n");
+  ErrorF("-title [title]       set the window title in the WM_NAME property\n");
+  ErrorF("\n");
+
+  exit(1);
+}
+#endif
+
+void
+processScreenArg (char *screen_size, char *parent_id)
+{
+  KdCardInfo   *card;
+
+  InitCard (0);  /*Put each screen on a separate card*/
+  card = KdCardInfoLast ();
+
+  if (card)
+    {
+      KdScreenInfo *screen;
+      unsigned long p_id = 0;
+
+      screen = KdScreenInfoAdd (card);
+      KdParseScreen (screen, screen_size);
+
+      if (parent_id)
+        {
+          p_id = strtol (parent_id, NULL, 0);
+        }
+      EPHYR_DBG ("screen number:%d\n", screen->mynum) ;
+      hostx_add_screen (screen, p_id, screen->mynum);
+    }
+  else
+    {
+      ErrorF("No matching card found!\n");
+    }
+}
+
+#ifndef _MSC_VER
+int
+ddxProcessArgument (int argc, char **argv, int i)
+{
+  static char* parent = NULL;
+  EPHYR_DBG("mark argv[%d]='%s'", i, argv[i] );
+
+  if (i == 1)
+    {
+      hostx_use_resname(basename(argv[0]), 0);
+    }
+
+  if (!strcmp (argv[i], "-parent"))
+    {
+      if(i+1 < argc)
+	{
+	  int j;
+	  /* If parent is specified and a screen argument follows, don't do
+           * anything, let the -screen handling init the rest */
+	  for (j = i; j < argc; j++)
+	    {
+	      if (!strcmp(argv[j], "-screen"))
+		{
+		  parent = argv[i + 1];
+		  return 2;
+		}
+	    }
+
+	  processScreenArg ("100x100", argv[i+1]);
+	  return 2;
+	}
+
+      UseMsg();
+      exit(1);
+    }
+  else if (!strcmp (argv[i], "-screen"))
+    {
+      if ((i+1) < argc)
+	{
+	  processScreenArg (argv[i+1], parent);
+	  parent = NULL;
+	  return 2;
+	}
+
+      UseMsg();
+      exit(1);
+    }
+  else if (!strcmp (argv[i], "-host-cursor"))
+    {
+      hostx_use_host_cursor();
+      return 1;
+    }
+  else if (!strcmp (argv[i], "-fullscreen"))
+    {
+      hostx_use_fullscreen();
+      return 1;
+    }
+  else if (!strcmp (argv[i], "-grayscale"))
+    {
+      EphyrWantGrayScale = 1;      
+      return 1;
+    }
+  else if (!strcmp (argv[i], "-fakexa"))
+    {
+      ephyrFuncs.initAccel = ephyrDrawInit;
+      ephyrFuncs.enableAccel = ephyrDrawEnable;
+      ephyrFuncs.disableAccel = ephyrDrawDisable;
+      ephyrFuncs.finiAccel = ephyrDrawFini;
+      return 1;
+    }
+  else if (!strcmp (argv[i], "-verbosity"))
+    {
+      if(i+1 < argc && argv[i+1][0] != '-')
+	{
+	  int verbosity=atoi (argv[i+1]) ;
+	  LogSetParameter (XLOG_VERBOSITY, verbosity) ;
+	  EPHYR_LOG ("set verbosiry to %d\n", verbosity) ;
+	  return 2 ;
+	}
+      else
+	{
+	  UseMsg() ;
+	  exit(1) ;
+	}
+    }
+#ifdef GLXEXT
+  else if (!strcmp (argv[i], "-nodri"))
+   {
+       noGlxVisualInit = FALSE ;
+       ephyrNoDRI = TRUE ;
+       EPHYR_LOG ("no direct rendering enabled\n") ;
+       return 1 ;
+   }
+#endif
+  else if (!strcmp (argv[i], "-noxv"))
+   {
+       ephyrNoXV = TRUE ;
+       EPHYR_LOG ("no XVideo enabled\n") ;
+       return 1 ;
+   }
+  else if (!strcmp (argv[i], "-name"))
+   {
+       if (i+1 < argc && argv[i+1][0] != '-')
+         {
+           hostx_use_resname(argv[i+1], 1);
+           return 2;
+         }
+       else
+         {
+           UseMsg();
+           return 0;
+         }
+   }
+  else if (!strcmp (argv[i], "-title"))
+   {
+       if (i+1 < argc && argv[i+1][0] != '-')
+         {
+           hostx_set_title(argv[i+1]);
+           return 2;
+         }
+       else
+         {
+           UseMsg();
+           return 0;
+         }
+   }
+  else if (argv[i][0] == ':')
+    {
+      hostx_set_display_name(argv[i]);
+    }
+  /* Xnest compatibility */
+  else if (!strcmp(argv[i], "-display"))
+  {
+      hostx_set_display_name(argv[i+1]);
+      return 2;
+  }
+  else if (!strcmp(argv[i], "-sync") ||
+	   !strcmp(argv[i], "-full") ||
+	   !strcmp(argv[i], "-sss") ||
+	   !strcmp(argv[i], "-install"))
+  {
+      return 1;
+  }
+  else if (!strcmp(argv[i], "-bw") ||
+	   !strcmp(argv[i], "-class") ||
+	   !strcmp(argv[i], "-geometry") ||
+	   !strcmp(argv[i], "-scrns"))
+  {
+      return 2;
+  }
+  /* end Xnest compat */
+
+  return KdProcessArgument (argc, argv, i);
+}
+
+void
+OsVendorInit (void)
+{
+  EPHYR_DBG("mark");
+
+  if (hostx_want_host_cursor())
+    {
+      ephyrFuncs.initCursor   = &ephyrCursorInit;
+      ephyrFuncs.enableCursor = &ephyrCursorEnable;
+    }
+
+  KdOsInit (&EphyrOsFuncs);
+}
+
+#ifdef DDXOSFATALERROR
+void
+OsVendorFatalError(void)
+{
+}
+#endif
+
+#endif
+
+/* 'Fake' cursor stuff, could be improved */
+
+static Bool
+ephyrRealizeCursor(DeviceIntPtr pDev, ScreenPtr pScreen, CursorPtr pCursor)
+{
+  return TRUE;
+}
+
+static Bool
+ephyrUnrealizeCursor(DeviceIntPtr pDev, ScreenPtr pScreen, CursorPtr pCursor)
+{
+  return TRUE;
+}
+
+static void
+ephyrSetCursor(DeviceIntPtr pDev, ScreenPtr pScreen, CursorPtr pCursor, int x, int y)
+{
+  ;
+}
+
+static void
+ephyrMoveCursor(DeviceIntPtr pDev, ScreenPtr pScreen, int x, int y)
+{
+  ;
+}
+
+static Bool
+ephyrDeviceCursorInitialize(DeviceIntPtr pDev, ScreenPtr pScreen)
+{
+  return TRUE;
+}
+
+static void
+ephyrDeviceCursorCleanup(DeviceIntPtr pDev, ScreenPtr pScreen)
+{
+}
+
+miPointerSpriteFuncRec EphyrPointerSpriteFuncs = {
+	ephyrRealizeCursor,
+	ephyrUnrealizeCursor,
+	ephyrSetCursor,
+	ephyrMoveCursor,
+	ephyrDeviceCursorInitialize,
+	ephyrDeviceCursorCleanup
+};
+
+
+Bool
+ephyrCursorInit(ScreenPtr pScreen)
+{
+  miPointerInitialize(pScreen,
+		      &EphyrPointerSpriteFuncs,
+		      &ephyrPointerScreenFuncs,
+		      FALSE);
+
+  return TRUE;
+}
+
+void
+ephyrCursorEnable(ScreenPtr pScreen)
+{
+  ;
+}
+
+KdCardFuncs ephyrFuncs = {
+    ephyrCardInit,	    /* cardinit */
+    ephyrScreenInit,	    /* scrinit */
+    ephyrInitScreen,	    /* initScreen */
+    ephyrFinishInitScreen,  /* finishInitScreen */
+    ephyrCreateResources,   /* createRes */
+    ephyrPreserve,	    /* preserve */
+    ephyrEnable,	    /* enable */
+    ephyrDPMS,		    /* dpms */
+    ephyrDisable,	    /* disable */
+    ephyrRestore,	    /* restore */
+    ephyrScreenFini,	    /* scrfini */
+    ephyrCardFini,	    /* cardfini */
+
+    0,			    /* initCursor */
+    0,			    /* enableCursor */
+    0,			    /* disableCursor */
+    0,			    /* finiCursor */
+    0,			    /* recolorCursor */
+
+    0,			    /* initAccel */
+    0,			    /* enableAccel */
+    0,			    /* disableAccel */
+    0,			    /* finiAccel */
+
+    ephyrGetColors,/* getColors */
+    ephyrPutColors,	    /* putColors */
+};
diff --git a/xorg-server/hw/kdrive/src/kdrive.c b/xorg-server/hw/kdrive/src/kdrive.c
index 85fe190fc..f5af57e82 100644
--- a/xorg-server/hw/kdrive/src/kdrive.c
+++ b/xorg-server/hw/kdrive/src/kdrive.c
@@ -1,1193 +1,1193 @@
-/*

- * Copyright © 1999 Keith Packard

- *

- * 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 Keith Packard not be used in

- * advertising or publicity pertaining to distribution of the software without

- * specific, written prior permission.  Keith Packard makes no

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

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

- *

- * KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,

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

- * EVENT SHALL KEITH PACKARD 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_CONFIG_H

-#include <kdrive-config.h>

-#endif

-#include "kdrive.h"

-#include <mivalidate.h>

-#include <dixstruct.h>

-#include "privates.h"

-#ifdef RANDR

-#include <randrstr.h>

-#endif

-

-#ifdef XV

-#include "kxv.h"

-#endif

-

-#ifdef DPMSExtension

-#include "dpmsproc.h"

-#endif

-

-#ifdef HAVE_EXECINFO_H

-#include <execinfo.h>

-#endif

-

-#include <signal.h>

-

-typedef struct _kdDepths {

-    CARD8   depth;

-    CARD8   bpp;

-} KdDepths;

-

-KdDepths    kdDepths[] = {

-    { 1, 1 },

-    { 4, 4 },

-    { 8, 8 },

-    { 15, 16 },

-    { 16, 16 },

-    { 24, 32 },

-    { 32, 32 }

-};

-

-#define NUM_KD_DEPTHS (sizeof (kdDepths) / sizeof (kdDepths[0]))

-

-#define KD_DEFAULT_BUTTONS 5

-

-DevPrivateKeyRec    kdScreenPrivateKeyRec;

-unsigned long	    kdGeneration;

-

-Bool                kdVideoTest;

-unsigned long       kdVideoTestTime;

-Bool		    kdEmulateMiddleButton;

-Bool		    kdRawPointerCoordinates;

-Bool		    kdDisableZaphod;

-Bool                kdAllowZap;

-Bool		    kdEnabled;

-int		    kdSubpixelOrder;

-int		    kdVirtualTerminal = -1;

-Bool		    kdSwitchPending;

-char		    *kdSwitchCmd;

-DDXPointRec	    kdOrigin;

-Bool		    kdHasPointer = FALSE;

-Bool		    kdHasKbd = FALSE;

-

-static Bool         kdCaughtSignal = FALSE;

-

-/*

- * Carry arguments from InitOutput through driver initialization

- * to KdScreenInit

- */

-

-KdOsFuncs	*kdOsFuncs;

-

-void

-KdDisableScreen (ScreenPtr pScreen)

-{

-    KdScreenPriv(pScreen);

-

-    if (!pScreenPriv->enabled)

-	return;

-    if (!pScreenPriv->closed)

-	SetRootClip (pScreen, FALSE);

-    KdDisableColormap (pScreen);

-    if (!pScreenPriv->screen->dumb && pScreenPriv->card->cfuncs->disableAccel)

-	(*pScreenPriv->card->cfuncs->disableAccel) (pScreen);

-    if (!pScreenPriv->screen->softCursor && pScreenPriv->card->cfuncs->disableCursor)

-	(*pScreenPriv->card->cfuncs->disableCursor) (pScreen);

-    if (pScreenPriv->card->cfuncs->dpms)

-	(*pScreenPriv->card->cfuncs->dpms) (pScreen, KD_DPMS_NORMAL);

-    pScreenPriv->enabled = FALSE;

-    if(pScreenPriv->card->cfuncs->disable)

-        (*pScreenPriv->card->cfuncs->disable) (pScreen);

-}

-

-static void

-KdDoSwitchCmd (char *reason)

-{

-    if (kdSwitchCmd)

-    {

-	char    *command = malloc(strlen (kdSwitchCmd) +

-				   1 +

-				   strlen (reason) +

-				   1);

-	if (!command)

-	    return;

-	strcpy (command, kdSwitchCmd);

-	strcat (command, " ");

-	strcat (command, reason);

-	system (command);

-	free(command);

-    }

-}

-

-void

-KdSuspend (void)

-{

-    KdCardInfo	    *card;

-    KdScreenInfo    *screen;

-

-    if (kdEnabled)

-    {

-	for (card = kdCardInfo; card; card = card->next)

-	{

-	    for (screen = card->screenList; screen; screen = screen->next)

-		if (screen->mynum == card->selected && screen->pScreen)

-		    KdDisableScreen (screen->pScreen);

-	    if (card->driver && card->cfuncs->restore)

-		(*card->cfuncs->restore) (card);

-	}

-	KdDisableInput ();

-	KdDoSwitchCmd ("suspend");

-    }

-}

-

-void

-KdDisableScreens (void)

-{

-    KdSuspend ();

-    if (kdEnabled)

-    {

-        if (kdOsFuncs->Disable)

-            (*kdOsFuncs->Disable) ();

-	kdEnabled = FALSE;

-    }

-}

-

-Bool

-KdEnableScreen (ScreenPtr pScreen)

-{

-    KdScreenPriv (pScreen);

-

-    if (pScreenPriv->enabled)

-	return TRUE;

-    if(pScreenPriv->card->cfuncs->enable)

-	if (!(*pScreenPriv->card->cfuncs->enable) (pScreen))

-	    return FALSE;

-    pScreenPriv->enabled = TRUE;

-    pScreenPriv->dpmsState = KD_DPMS_NORMAL;

-    pScreenPriv->card->selected = pScreenPriv->screen->mynum;

-    if (!pScreenPriv->screen->softCursor && pScreenPriv->card->cfuncs->enableCursor)

-	(*pScreenPriv->card->cfuncs->enableCursor) (pScreen);

-    if (!pScreenPriv->screen->dumb && pScreenPriv->card->cfuncs->enableAccel)

-	(*pScreenPriv->card->cfuncs->enableAccel) (pScreen);

-    KdEnableColormap (pScreen);

-    SetRootClip (pScreen, TRUE);

-    if (pScreenPriv->card->cfuncs->dpms)

-	(*pScreenPriv->card->cfuncs->dpms) (pScreen, pScreenPriv->dpmsState);

-    return TRUE;

-}

-

-void

-KdResume (void)

-{

-    KdCardInfo	    *card;

-    KdScreenInfo    *screen;

-

-    if (kdEnabled)

-    {

-	KdDoSwitchCmd ("resume");

-	for (card = kdCardInfo; card; card = card->next)

-	{

-	    if(card->cfuncs->preserve)

-		(*card->cfuncs->preserve) (card);

-	    for (screen = card->screenList; screen; screen = screen->next)

-		if (screen->mynum == card->selected && screen->pScreen)

-		    KdEnableScreen (screen->pScreen);

-	}

-	KdEnableInput ();

-	KdReleaseAllKeys ();

-    }

-}

-

-void

-KdEnableScreens (void)

-{

-    if (!kdEnabled)

-    {

-	kdEnabled = TRUE;

-        if (kdOsFuncs->Enable)

-            (*kdOsFuncs->Enable) ();

-    }

-    KdResume ();

-}

-

-void

-KdProcessSwitch (void)

-{

-    if (kdEnabled)

-	KdDisableScreens ();

-    else

-	KdEnableScreens ();

-}

-

-#ifndef _MSC_VER

-void

-AbortDDX(enum ExitCode error)

-{

-    KdDisableScreens ();

-    if (kdOsFuncs)

-    {

-	if (kdEnabled && kdOsFuncs->Disable)

-	    (*kdOsFuncs->Disable) ();

-        if (kdOsFuncs->Fini)

-            (*kdOsFuncs->Fini) ();

-	KdDoSwitchCmd ("stop");

-    }

-

-    if (kdCaughtSignal)

-        OsAbort();

-}

-

-void

-ddxGiveUp (enum ExitCode error)

-{

-    AbortDDX (error);

-}

-#endif

-

-Bool	kdDumbDriver;

-Bool	kdSoftCursor;

-

-char *

-KdParseFindNext (char *cur, char *delim, char *save, char *last)

-{

-    while (*cur && !strchr (delim, *cur))

-    {

-	*save++ = *cur++;

-    }

-    *save = 0;

-    *last = *cur;

-    if (*cur)

-	cur++;

-    return cur;

-}

-

-Rotation

-KdAddRotation (Rotation a, Rotation b)

-{

-    Rotation	rotate = (a & RR_Rotate_All) * (b & RR_Rotate_All);

-    Rotation	reflect = (a & RR_Reflect_All) ^ (b & RR_Reflect_All);

-

-    if (rotate > RR_Rotate_270)

-	rotate /= (RR_Rotate_270 * RR_Rotate_90);

-    return reflect | rotate;

-}

-

-Rotation

-KdSubRotation (Rotation a, Rotation b)

-{

-    Rotation	rotate = (a & RR_Rotate_All) * 16 / (b & RR_Rotate_All);

-    Rotation	reflect = (a & RR_Reflect_All) ^ (b & RR_Reflect_All);

-

-    if (rotate > RR_Rotate_270)

-	rotate /= (RR_Rotate_270 * RR_Rotate_90);

-    return reflect | rotate;

-}

-

-void

-KdParseScreen (KdScreenInfo *screen,

-	       char	    *arg)

-{

-    char    delim;

-    char    save[1024];

-    int	    i;

-    int	    pixels, mm;

-

-    screen->dumb = kdDumbDriver;

-    screen->softCursor = kdSoftCursor;

-    screen->origin = kdOrigin;

-    screen->randr = RR_Rotate_0;

-    screen->width = 0;

-    screen->height = 0;

-    screen->width_mm = 0;

-    screen->height_mm = 0;

-    screen->subpixel_order = kdSubpixelOrder;

-    screen->rate = 0;

-    screen->fb.depth = 0;

-    if (!arg)

-	return;

-    if (strlen (arg) >= sizeof (save))

-	return;

-

-    for (i = 0; i < 2; i++)

-    {

-	arg = KdParseFindNext (arg, "x/@XY", save, &delim);

-	if (!save[0])

-	    return;

-

-	pixels = atoi(save);

-	mm = 0;

-

-	if (delim == '/')

-	{

-	    arg = KdParseFindNext (arg, "x@XY", save, &delim);

-	    if (!save[0])

-		return;

-	    mm = atoi(save);

-	}

-

-	if (i == 0)

-	{

-	    screen->width = pixels;

-	    screen->width_mm = mm;

-	}

-	else

-	{

-	    screen->height = pixels;

-	    screen->height_mm = mm;

-	}

-	if (delim != 'x' && delim != '@' && delim != 'X' && delim != 'Y')

-	    return;

-    }

-

-    kdOrigin.x += screen->width;

-    kdOrigin.y = 0;

-    kdDumbDriver = FALSE;

-    kdSoftCursor = FALSE;

-    kdSubpixelOrder = SubPixelUnknown;

-

-    if (delim == '@')

-    {

-	arg = KdParseFindNext (arg, "xXY", save, &delim);

-	if (save[0])

-	{

-	    int	    rotate = atoi (save);

-	    if (rotate < 45)

-		screen->randr = RR_Rotate_0;

-	    else if (rotate < 135)

-		screen->randr = RR_Rotate_90;

-	    else if (rotate < 225)

-		screen->randr = RR_Rotate_180;

-	    else if (rotate < 315)

-		screen->randr = RR_Rotate_270;

-	    else

-		screen->randr = RR_Rotate_0;

-	}

-    }

-    if (delim == 'X')

-    {

-	arg = KdParseFindNext (arg, "xY", save, &delim);

-	screen->randr |= RR_Reflect_X;

-    }

-

-    if (delim == 'Y')

-    {

-	arg = KdParseFindNext (arg, "xY", save, &delim);

-	screen->randr |= RR_Reflect_Y;

-    }

-

-    arg = KdParseFindNext (arg, "x/,", save, &delim);

-    if (save[0])

-    {

-	screen->fb.depth = atoi(save);

-	if (delim == '/')

-	{

-	    arg = KdParseFindNext (arg, "x,", save, &delim);

-	    if (save[0])

-		screen->fb.bitsPerPixel = atoi (save);

-	}

-	else

-	    screen->fb.bitsPerPixel = 0;

-    }

-

-    if (delim == 'x')

-    {

-	arg = KdParseFindNext (arg, "x", save, &delim);

-	if (save[0])

-	    screen->rate = atoi(save);

-    }

-}

-

-/*

- * Mouse argument syntax:

- *

- *  device,protocol,options...

- *

- *  Options are any of:

- *	1-5	    n button mouse

- *	2button	    emulate middle button

- *	{NMO}	    Reorder buttons

- */

-

-void

-KdParseRgba (char *rgba)

-{

-    if (!strcmp (rgba, "rgb"))

-	kdSubpixelOrder = SubPixelHorizontalRGB;

-    else if (!strcmp (rgba, "bgr"))

-	kdSubpixelOrder = SubPixelHorizontalBGR;

-    else if (!strcmp (rgba, "vrgb"))

-	kdSubpixelOrder = SubPixelVerticalRGB;

-    else if (!strcmp (rgba, "vbgr"))

-	kdSubpixelOrder = SubPixelVerticalBGR;

-    else if (!strcmp (rgba, "none"))

-	kdSubpixelOrder = SubPixelNone;

-    else

-	kdSubpixelOrder = SubPixelUnknown;

-}

-

-void

-KdUseMsg (void)

-{

-    ErrorF("\nTinyX Device Dependent Usage:\n");

-    ErrorF("-screen WIDTH[/WIDTHMM]xHEIGHT[/HEIGHTMM][@ROTATION][X][Y][xDEPTH/BPP[xFREQ]]  Specify screen characteristics\n");

-    ErrorF("-rgba rgb/bgr/vrgb/vbgr/none   Specify subpixel ordering for LCD panels\n");

-    ErrorF("-mouse driver [,n,,options]    Specify the pointer driver and its options (n is the number of buttons)\n");

-    ErrorF("-keybd driver [,,options]      Specify the keyboard driver and its options\n");

-    ErrorF("-zaphod          Disable cursor screen switching\n");

-    ErrorF("-2button         Emulate 3 button mouse\n");

-    ErrorF("-3button         Disable 3 button mouse emulation\n");

-    ErrorF("-rawcoord        Don't transform pointer coordinates on rotation\n");

-    ErrorF("-dumb            Disable hardware acceleration\n");

-    ErrorF("-softCursor      Force software cursor\n");

-    ErrorF("-videoTest       Start the server, pause momentarily and exit\n");

-    ErrorF("-origin X,Y      Locates the next screen in the the virtual screen (Xinerama)\n");

-    ErrorF("-switchCmd       Command to execute on vt switch\n");

-    ErrorF("-zap             Terminate server on Ctrl+Alt+Backspace\n");

-    ErrorF("vtxx             Use virtual terminal xx instead of the next available\n");

-}

-

-int

-KdProcessArgument (int argc, char **argv, int i)

-{

-    KdCardInfo	    *card;

-    KdScreenInfo    *screen;

-

-    if (!strcmp (argv[i], "-screen"))

-    {

-	if ((i+1) < argc)

-	{

-	    card = KdCardInfoLast ();

-	    if (!card)

-	    {

-		InitCard (0);

-		card = KdCardInfoLast ();

-	    }

-	    if (card) {

-		screen = KdScreenInfoAdd (card);

-		KdParseScreen (screen, argv[i+1]);

-	    } else

-		ErrorF("No matching card found!\n");

-	}

-	else

-	    UseMsg ();

-	return 2;

-    }

-    if (!strcmp (argv[i], "-zaphod"))

-    {

-	kdDisableZaphod = TRUE;

-	return 1;

-    }

-    if (!strcmp (argv[i], "-zap"))

-    {

-	kdAllowZap = TRUE;

-	return 1;

-    }

-    if (!strcmp (argv[i], "-3button"))

-    {

-	kdEmulateMiddleButton = FALSE;

-	return 1;

-    }

-    if (!strcmp (argv[i], "-2button"))

-    {

-	kdEmulateMiddleButton = TRUE;

-	return 1;

-    }

-    if (!strcmp (argv[i], "-rawcoord"))

-    {

-	kdRawPointerCoordinates = 1;

-	return 1;

-    }

-    if (!strcmp (argv[i], "-dumb"))

-    {

-	kdDumbDriver = TRUE;

-	return 1;

-    }

-    if (!strcmp (argv[i], "-softCursor"))

-    {

-	kdSoftCursor = TRUE;

-	return 1;

-    }

-    if (!strcmp (argv[i], "-videoTest"))

-    {

-	kdVideoTest = TRUE;

-	return 1;

-    }

-    if (!strcmp (argv[i], "-origin"))

-    {

-	if ((i+1) < argc)

-	{

-	    char    *x = argv[i+1];

-	    char    *y = strchr (x, ',');

-	    if (x)

-		kdOrigin.x = atoi (x);

-	    else

-		kdOrigin.x = 0;

-	    if (y)

-		kdOrigin.y = atoi(y+1);

-	    else

-		kdOrigin.y = 0;

-	}

-	else

-	    UseMsg ();

-	return 2;

-    }

-    if (!strcmp (argv[i], "-rgba"))

-    {

-	if ((i+1) < argc)

-	    KdParseRgba (argv[i+1]);

-	else

-	    UseMsg ();

-	return 2;

-    }

-    if (!strcmp (argv[i], "-switchCmd"))

-    {

-	if ((i+1) < argc)

-	    kdSwitchCmd = argv[i+1];

-	else

-	    UseMsg ();

-	return 2;

-    }

-    if (!strncmp (argv[i], "vt", 2) &&

-	sscanf (argv[i], "vt%2d", &kdVirtualTerminal) == 1)

-    {

-	return 1;

-    }

-    if (!strcmp (argv[i], "-mouse") ||

-        !strcmp (argv[i], "-pointer")) {

-        if (i + 1 >= argc)

-            UseMsg();

-        KdAddConfigPointer(argv[i + 1]);

-	kdHasPointer = TRUE;

-        return 2;

-    }

-    if (!strcmp (argv[i], "-keybd")) {

-        if (i + 1 >= argc)

-            UseMsg();

-        KdAddConfigKeyboard(argv[i + 1]);

-	kdHasKbd = TRUE;

-        return 2;

-    }

-

-    return 0;

-}

-

-/*

- * These are getting tossed in here until I can think of where

- * they really belong

- */

-

-void

-KdOsInit (KdOsFuncs *pOsFuncs)

-{

-    kdOsFuncs = pOsFuncs;

-    if (pOsFuncs)

-    {

-	if (serverGeneration == 1)

-	{

-	    KdDoSwitchCmd ("start");

-            if (pOsFuncs->Init)

-                (*pOsFuncs->Init) ();

-	}

-    }

-}

-

-Bool

-KdAllocatePrivates (ScreenPtr pScreen)

-{

-    KdPrivScreenPtr	pScreenPriv;

-

-    if (kdGeneration != serverGeneration)

-	kdGeneration = serverGeneration;

-

-    if (!dixRegisterPrivateKey(&kdScreenPrivateKeyRec, PRIVATE_SCREEN, 0))

-	return FALSE;

-

-    pScreenPriv = calloc(1, sizeof (*pScreenPriv));

-    if (!pScreenPriv)

-	return FALSE;

-    KdSetScreenPriv (pScreen, pScreenPriv);

-    return TRUE;

-}

-

-Bool

-KdCreateScreenResources (ScreenPtr pScreen)

-{

-    KdScreenPriv(pScreen);

-    KdCardInfo	    *card = pScreenPriv->card;

-    Bool ret;

-

-    pScreen->CreateScreenResources = pScreenPriv->CreateScreenResources;

-    if(pScreen->CreateScreenResources)

-	ret = (*pScreen->CreateScreenResources) (pScreen);

-    else

-	ret= -1;

-    pScreenPriv->CreateScreenResources = pScreen->CreateScreenResources;

-    pScreen->CreateScreenResources = KdCreateScreenResources;

-    if (ret && card->cfuncs->createRes)

-	ret = (*card->cfuncs->createRes) (pScreen);

-    return ret;

-}

-

-Bool

-KdCloseScreen (int index, ScreenPtr pScreen)

-{

-    KdScreenPriv(pScreen);

-    KdScreenInfo    *screen = pScreenPriv->screen;

-    KdCardInfo	    *card = pScreenPriv->card;

-    Bool	    ret;

-

-    pScreenPriv->closed = TRUE;

-    pScreen->CloseScreen = pScreenPriv->CloseScreen;

-    if(pScreen->CloseScreen)

-        ret = (*pScreen->CloseScreen) (index, pScreen);

-    else

-	ret = TRUE;

-

-    if (pScreenPriv->dpmsState != KD_DPMS_NORMAL)

-	(*card->cfuncs->dpms) (pScreen, KD_DPMS_NORMAL);

-

-    if (screen->mynum == card->selected)

-	KdDisableScreen (pScreen);

-

-    /*

-     * Restore video hardware when last screen is closed

-     */

-    if (screen == card->screenList)

-    {

-	if (kdEnabled && card->cfuncs->restore)

-	    (*card->cfuncs->restore) (card);

-    }

-

-    if (!pScreenPriv->screen->dumb && card->cfuncs->finiAccel)

-	(*card->cfuncs->finiAccel) (pScreen);

-

-    if (!pScreenPriv->screen->softCursor && card->cfuncs->finiCursor)

-	(*card->cfuncs->finiCursor) (pScreen);

-

-    if(card->cfuncs->scrfini)

-        (*card->cfuncs->scrfini) (screen);

-

-    /*

-     * Clean up card when last screen is closed, DIX closes them in

-     * reverse order, thus we check for when the first in the list is closed

-     */

-    if (screen == card->screenList)

-    {

-	if(card->cfuncs->cardfini)

-	    (*card->cfuncs->cardfini) (card);

-	/*

-	 * Clean up OS when last card is closed

-	 */

-	if (card == kdCardInfo)

-	{

-	    if (kdEnabled)

-	    {

-		kdEnabled = FALSE;

-		if(kdOsFuncs->Disable)

-		    (*kdOsFuncs->Disable) ();

-	    }

-	}

-    }

-

-    pScreenPriv->screen->pScreen = 0;

-

-    free((pointer) pScreenPriv);

-    return ret;

-}

-

-Bool

-KdSaveScreen (ScreenPtr pScreen, int on)

-{

-    KdScreenPriv(pScreen);

-    int	    dpmsState;

-

-    if (!pScreenPriv->card->cfuncs->dpms)

-	return FALSE;

-

-    dpmsState = pScreenPriv->dpmsState;

-    switch (on) {

-    case SCREEN_SAVER_OFF:

-	dpmsState = KD_DPMS_NORMAL;

-	break;

-    case SCREEN_SAVER_ON:

-	if (dpmsState == KD_DPMS_NORMAL)

-	    dpmsState = KD_DPMS_NORMAL+1;

-	break;

-    case SCREEN_SAVER_CYCLE:

-	if (dpmsState < KD_DPMS_MAX)

-	    dpmsState++;

-	break;

-    case SCREEN_SAVER_FORCER:

-	break;

-    }

-    if (dpmsState != pScreenPriv->dpmsState)

-    {

-	if (pScreenPriv->enabled)

-	    (*pScreenPriv->card->cfuncs->dpms) (pScreen, dpmsState);

-	pScreenPriv->dpmsState = dpmsState;

-    }

-    return TRUE;

-}

-

-static Bool

-KdCreateWindow (WindowPtr pWin)

-{

-#ifndef PHOENIX

-    if (!pWin->parent)

-    {

-	KdScreenPriv(pWin->drawable.pScreen);

-

-	if (!pScreenPriv->enabled)

-	{

-	    RegionEmpty(&pWin->borderClip);

-	    RegionBreak(&pWin->clipList);

-	}

-    }

-#endif

-    return fbCreateWindow (pWin);

-}

-

-void

-KdSetSubpixelOrder (ScreenPtr pScreen, Rotation randr)

-{

-    KdScreenPriv(pScreen);

-    KdScreenInfo	*screen = pScreenPriv->screen;

-    int			subpixel_order = screen->subpixel_order;

-    Rotation		subpixel_dir;

-    int			i;

-

-    static struct {

-	int	    subpixel_order;

-	Rotation    direction;

-    } orders[] = {

-	{ SubPixelHorizontalRGB, 	RR_Rotate_0 },

-	{ SubPixelHorizontalBGR,	RR_Rotate_180 },

-	{ SubPixelVerticalRGB,		RR_Rotate_270 },

-	{ SubPixelVerticalBGR,		RR_Rotate_90 },

-    };

-

-    static struct {

-	int	bit;

-	int	normal;

-	int	reflect;

-    } reflects[] = {

-	{ RR_Reflect_X, SubPixelHorizontalRGB,	SubPixelHorizontalBGR },

-	{ RR_Reflect_X, SubPixelHorizontalBGR,	SubPixelHorizontalRGB },

-	{ RR_Reflect_Y, SubPixelVerticalRGB,	SubPixelVerticalBGR },

-	{ RR_Reflect_Y, SubPixelVerticalRGB,	SubPixelVerticalRGB },

-    };

-

-    /* map subpixel to direction */

-    for (i = 0; i < 4; i++)

-	if (orders[i].subpixel_order == subpixel_order)

-	    break;

-    if (i < 4)

-    {

-	subpixel_dir = KdAddRotation (randr & RR_Rotate_All, orders[i].direction);

-

-	/* map back to subpixel order */

-	for (i = 0; i < 4; i++)

-	    if (orders[i].direction & subpixel_dir)

-	    {

-		subpixel_order = orders[i].subpixel_order;

-		break;

-	    }

-	/* reflect */

-	for (i = 0; i < 4; i++)

-	    if ((randr & reflects[i].bit) &&

-		reflects[i].normal == subpixel_order)

-	    {

-		subpixel_order = reflects[i].reflect;

-		break;

-	    }

-    }

-    PictureSetSubpixelOrder (pScreen, subpixel_order);

-}

-

-/* Pass through AddScreen, which doesn't take any closure */

-static KdScreenInfo *kdCurrentScreen;

-

-Bool

-KdScreenInit(int index, ScreenPtr pScreen, int argc, char **argv)

-{

-    KdScreenInfo	*screen = kdCurrentScreen;

-    KdCardInfo		*card = screen->card;

-    KdPrivScreenPtr	pScreenPriv;

-    /*

-     * note that screen->fb is set up for the nominal orientation

-     * of the screen; that means if randr is rotated, the values

-     * there should reflect a rotated frame buffer (or shadow).

-     */

-    Bool		rotated = (screen->randr & (RR_Rotate_90|RR_Rotate_270)) != 0;

-    int			width, height, *width_mmp, *height_mmp;

-

-    KdAllocatePrivates (pScreen);

-

-    pScreenPriv = KdGetScreenPriv(pScreen);

-

-    if (!rotated)

-    {

-	width = screen->width;

-	height = screen->height;

-	width_mmp = &screen->width_mm;

-	height_mmp = &screen->height_mm;

-    }

-    else

-    {

-	width = screen->height;

-	height = screen->width;

-	width_mmp = &screen->height_mm;

-	height_mmp = &screen->width_mm;

-    }

-    screen->pScreen = pScreen;

-    pScreenPriv->screen = screen;

-    pScreenPriv->card = card;

-    pScreenPriv->bytesPerPixel = screen->fb.bitsPerPixel >> 3;

-    pScreenPriv->dpmsState = KD_DPMS_NORMAL;

-    pScreen->x = screen->origin.x;

-    pScreen->y = screen->origin.y;

-

-    if (!monitorResolution)

-	monitorResolution = 75;

-    /*

-     * This is done in this order so that backing store wraps

-     * our GC functions; fbFinishScreenInit initializes MI

-     * backing store

-     */

-    if (!fbSetupScreen (pScreen,

-			screen->fb.frameBuffer,

-			width, height,

-			monitorResolution, monitorResolution,

-			screen->fb.pixelStride,

-			screen->fb.bitsPerPixel))

-    {

-	return FALSE;

-    }

-

-    /*

-     * Set colormap functions

-     */

-    pScreen->InstallColormap	= KdInstallColormap;

-    pScreen->UninstallColormap	= KdUninstallColormap;

-    pScreen->ListInstalledColormaps = KdListInstalledColormaps;

-    pScreen->StoreColors	= KdStoreColors;

-

-    pScreen->SaveScreen		= KdSaveScreen;

-    pScreen->CreateWindow	= KdCreateWindow;

-

-    if (!fbFinishScreenInit (pScreen,

-			     screen->fb.frameBuffer,

-			     width, height,

-			     monitorResolution, monitorResolution,

-			     screen->fb.pixelStride,

-			     screen->fb.bitsPerPixel))

-    {

-	return FALSE;

-    }

-

-    /*

-     * Fix screen sizes; for some reason mi takes dpi instead of mm.

-     * Rounding errors are annoying

-     */

-    if (*width_mmp)

-	pScreen->mmWidth = *width_mmp;

-    else

-	*width_mmp = pScreen->mmWidth;

-    if (*height_mmp)

-	pScreen->mmHeight = *height_mmp;

-    else

-	*height_mmp = pScreen->mmHeight;

-

-    /*

-     * Plug in our own block/wakeup handlers.

-     * miScreenInit installs NoopDDA in both places

-     */

-    pScreen->BlockHandler	= KdBlockHandler;

-    pScreen->WakeupHandler	= KdWakeupHandler;

-

-    if (!fbPictureInit (pScreen, 0, 0))

-	return FALSE;

-    if (card->cfuncs->initScreen)

-	if (!(*card->cfuncs->initScreen) (pScreen))

-	    return FALSE;

-

-    if (!screen->dumb && card->cfuncs->initAccel)

-	if (!(*card->cfuncs->initAccel) (pScreen))

-	    screen->dumb = TRUE;

-

-    if (card->cfuncs->finishInitScreen)

-	if (!(*card->cfuncs->finishInitScreen) (pScreen))

-	    return FALSE;

-

-#if 0

-    fbInitValidateTree (pScreen);

-#endif

-

-    /*

-     * Wrap CloseScreen, the order now is:

-     *	KdCloseScreen

-     *	miBSCloseScreen

-     *	fbCloseScreen

-     */

-    pScreenPriv->CloseScreen = pScreen->CloseScreen;

-    pScreen->CloseScreen = KdCloseScreen;

-

-    pScreenPriv->CreateScreenResources = pScreen->CreateScreenResources;

-    pScreen->CreateScreenResources = KdCreateScreenResources;

-

-    if (screen->softCursor ||

-	!card->cfuncs->initCursor ||

-	!(*card->cfuncs->initCursor) (pScreen))

-    {

-	/* Use MI for cursor display and event queueing. */

-	screen->softCursor = TRUE;

-	miDCInitialize(pScreen, &kdPointerScreenFuncs);

-    }

-

-

-    if (!fbCreateDefColormap (pScreen))

-    {

-	return FALSE;

-    }

-

-    KdSetSubpixelOrder (pScreen, screen->randr);

-

-    /*

-     * Enable the hardware

-     */

-    if (!kdEnabled)

-    {

-	kdEnabled = TRUE;

-	if(kdOsFuncs->Enable)

-	    (*kdOsFuncs->Enable) ();

-    }

-

-    if (screen->mynum == card->selected)

-    {

-	if(card->cfuncs->preserve)

-	    (*card->cfuncs->preserve) (card);

-	if(card->cfuncs->enable)

-	    if (!(*card->cfuncs->enable) (pScreen))

-		return FALSE;

-	pScreenPriv->enabled = TRUE;

-	if (!screen->softCursor && card->cfuncs->enableCursor)

-	    (*card->cfuncs->enableCursor) (pScreen);

-	KdEnableColormap (pScreen);

-	if (!screen->dumb && card->cfuncs->enableAccel)

-	    (*card->cfuncs->enableAccel) (pScreen);

-    }

-

-    return TRUE;

-}

-

-void

-KdInitScreen (ScreenInfo    *pScreenInfo,

-	      KdScreenInfo  *screen,

-	      int	    argc,

-	      char	    **argv)

-{

-    KdCardInfo	*card = screen->card;

-

-    (*card->cfuncs->scrinit) (screen);

-

-    if (!card->cfuncs->initAccel)

-	screen->dumb = TRUE;

-    if (!card->cfuncs->initCursor)

-	screen->softCursor = TRUE;

-}

-

-static Bool

-KdSetPixmapFormats (ScreenInfo	*pScreenInfo)

-{

-    CARD8	    depthToBpp[33];	/* depth -> bpp map */

-    KdCardInfo	    *card;

-    KdScreenInfo    *screen;

-    int		    i;

-    int		    bpp;

-    PixmapFormatRec *format;

-

-    for (i = 1; i <= 32; i++)

-	depthToBpp[i] = 0;

-

-    /*

-     * Generate mappings between bitsPerPixel and depth,

-     * also ensure that all screens comply with protocol

-     * restrictions on equivalent formats for the same

-     * depth on different screens

-     */

-    for (card = kdCardInfo; card; card = card->next)

-    {

-	for (screen = card->screenList; screen; screen = screen->next)

-	{

-	    bpp = screen->fb.bitsPerPixel;

-	    if (bpp == 24)

-		bpp = 32;

-	    if (!depthToBpp[screen->fb.depth])

-		depthToBpp[screen->fb.depth] = bpp;

-	    else if (depthToBpp[screen->fb.depth] != bpp)

-		return FALSE;

-	}

-    }

-

-    /*

-     * Fill in additional formats

-     */

-    for (i = 0; i < NUM_KD_DEPTHS; i++)

-	if (!depthToBpp[kdDepths[i].depth])

-	    depthToBpp[kdDepths[i].depth] = kdDepths[i].bpp;

-

-    pScreenInfo->imageByteOrder     = IMAGE_BYTE_ORDER;

-    pScreenInfo->bitmapScanlineUnit = BITMAP_SCANLINE_UNIT;

-    pScreenInfo->bitmapScanlinePad  = BITMAP_SCANLINE_PAD;

-    pScreenInfo->bitmapBitOrder     = BITMAP_BIT_ORDER;

-

-    pScreenInfo->numPixmapFormats = 0;

-

-    for (i = 1; i <= 32; i++)

-    {

-	if (depthToBpp[i])

-	{

-	    format = &pScreenInfo->formats[pScreenInfo->numPixmapFormats++];

-	    format->depth = i;

-	    format->bitsPerPixel = depthToBpp[i];

-	    format->scanlinePad = BITMAP_SCANLINE_PAD;

-	}

-    }

-

-    return TRUE;

-}

-

-static void

-KdAddScreen (ScreenInfo	    *pScreenInfo,

-	     KdScreenInfo   *screen,

-	     int	    argc,

-	     char	    **argv)

-{

-    int	    i;

-    /*

-     * Fill in fb visual type masks for this screen

-     */

-    for (i = 0; i < pScreenInfo->numPixmapFormats; i++)

-    {

-	unsigned long	visuals;

-	Pixel		rm, gm, bm;

-

-	visuals = 0;

-	rm = gm = bm = 0;

-	if (pScreenInfo->formats[i].depth == screen->fb.depth)

-	{

-	    visuals = screen->fb.visuals;

-	    rm = screen->fb.redMask;

-	    gm = screen->fb.greenMask;

-	    bm = screen->fb.blueMask;

-	}

-	fbSetVisualTypesAndMasks (pScreenInfo->formats[i].depth,

-				  visuals,

-				  8,

-				  rm, gm, bm);

-    }

-

-    kdCurrentScreen = screen;

-

-    AddScreen (KdScreenInit, argc, argv);

-}

-

-#if 0 /* This function is not used currently */

-

-int

-KdDepthToFb (ScreenPtr	pScreen, int depth)

-{

-    KdScreenPriv(pScreen);

-

-    for (fb = 0; fb <= KD_MAX_FB && pScreenPriv->screen->fb.frameBuffer; fb++)

-	if (pScreenPriv->screen->fb.depth == depth)

-	    return fb;

-}

-

-#endif

-

-static int

-KdSignalWrapper (int signum)

-{

-    kdCaughtSignal = TRUE;

-    return 1; /* use generic OS layer cleanup & abort */

-}

-

-void

-KdInitOutput (ScreenInfo    *pScreenInfo,

-	      int	    argc,

-	      char	    **argv)

-{

-    KdCardInfo	    *card;

-    KdScreenInfo    *screen;

-

-    if (!kdCardInfo)

-    {

-	InitCard (0);

-	if (!(card = KdCardInfoLast ()))

-	    FatalError("No matching cards found!\n");

-	screen = KdScreenInfoAdd (card);

-	KdParseScreen (screen, 0);

-    }

-    /*

-     * Initialize all of the screens for all of the cards

-     */

-    for (card = kdCardInfo; card; card = card->next)

-    {

-	int ret=1;

-	if(card->cfuncs->cardinit)

-		ret=(*card->cfuncs->cardinit) (card);

-	if (ret)

-	{

-	    for (screen = card->screenList; screen; screen = screen->next)

-		KdInitScreen (pScreenInfo, screen, argc, argv);

-	}

-    }

-

-    /*

-     * Merge the various pixmap formats together, this can fail

-     * when two screens share depth but not bitsPerPixel

-     */

-    if (!KdSetPixmapFormats (pScreenInfo))

-	return;

-

-    /*

-     * Add all of the screens

-     */

-    for (card = kdCardInfo; card; card = card->next)

-	for (screen = card->screenList; screen; screen = screen->next)

-	    KdAddScreen (pScreenInfo, screen, argc, argv);

-

-    OsRegisterSigWrapper(KdSignalWrapper);

-}

-

-#ifndef _MSC_VER

-void

-OsVendorFatalError(void)

-{

-}

-

-int

-DPMSSet(ClientPtr client, int level)

-{

-    return Success;

-}

-

-Bool

-DPMSSupported (void)

-{

-    return FALSE;

-}

-#endif

+/*
+ * Copyright © 1999 Keith Packard
+ *
+ * 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 Keith Packard not be used in
+ * advertising or publicity pertaining to distribution of the software without
+ * specific, written prior permission.  Keith Packard makes no
+ * representations about the suitability of this software for any purpose.  It
+ * is provided "as is" without express or implied warranty.
+ *
+ * KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
+ * EVENT SHALL KEITH PACKARD 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_CONFIG_H
+#include <kdrive-config.h>
+#endif
+#include "kdrive.h"
+#include <mivalidate.h>
+#include <dixstruct.h>
+#include "privates.h"
+#ifdef RANDR
+#include <randrstr.h>
+#endif
+
+#ifdef XV
+#include "kxv.h"
+#endif
+
+#ifdef DPMSExtension
+#include "dpmsproc.h"
+#endif
+
+#ifdef HAVE_EXECINFO_H
+#include <execinfo.h>
+#endif
+
+#include <signal.h>
+
+typedef struct _kdDepths {
+    CARD8   depth;
+    CARD8   bpp;
+} KdDepths;
+
+KdDepths    kdDepths[] = {
+    { 1, 1 },
+    { 4, 4 },
+    { 8, 8 },
+    { 15, 16 },
+    { 16, 16 },
+    { 24, 32 },
+    { 32, 32 }
+};
+
+#define NUM_KD_DEPTHS (sizeof (kdDepths) / sizeof (kdDepths[0]))
+
+#define KD_DEFAULT_BUTTONS 5
+
+DevPrivateKeyRec    kdScreenPrivateKeyRec;
+unsigned long	    kdGeneration;
+
+Bool                kdVideoTest;
+unsigned long       kdVideoTestTime;
+Bool		    kdEmulateMiddleButton;
+Bool		    kdRawPointerCoordinates;
+Bool		    kdDisableZaphod;
+Bool                kdAllowZap;
+Bool		    kdEnabled;
+int		    kdSubpixelOrder;
+int		    kdVirtualTerminal = -1;
+Bool		    kdSwitchPending;
+char		    *kdSwitchCmd;
+DDXPointRec	    kdOrigin;
+Bool		    kdHasPointer = FALSE;
+Bool		    kdHasKbd = FALSE;
+
+static Bool         kdCaughtSignal = FALSE;
+
+/*
+ * Carry arguments from InitOutput through driver initialization
+ * to KdScreenInit
+ */
+
+KdOsFuncs	*kdOsFuncs;
+
+void
+KdDisableScreen (ScreenPtr pScreen)
+{
+    KdScreenPriv(pScreen);
+
+    if (!pScreenPriv->enabled)
+	return;
+    if (!pScreenPriv->closed)
+	SetRootClip (pScreen, FALSE);
+    KdDisableColormap (pScreen);
+    if (!pScreenPriv->screen->dumb && pScreenPriv->card->cfuncs->disableAccel)
+	(*pScreenPriv->card->cfuncs->disableAccel) (pScreen);
+    if (!pScreenPriv->screen->softCursor && pScreenPriv->card->cfuncs->disableCursor)
+	(*pScreenPriv->card->cfuncs->disableCursor) (pScreen);
+    if (pScreenPriv->card->cfuncs->dpms)
+	(*pScreenPriv->card->cfuncs->dpms) (pScreen, KD_DPMS_NORMAL);
+    pScreenPriv->enabled = FALSE;
+    if(pScreenPriv->card->cfuncs->disable)
+        (*pScreenPriv->card->cfuncs->disable) (pScreen);
+}
+
+static void
+KdDoSwitchCmd (char *reason)
+{
+    if (kdSwitchCmd)
+    {
+	char    *command = malloc(strlen (kdSwitchCmd) +
+				   1 +
+				   strlen (reason) +
+				   1);
+	if (!command)
+	    return;
+	strcpy (command, kdSwitchCmd);
+	strcat (command, " ");
+	strcat (command, reason);
+	system (command);
+	free(command);
+    }
+}
+
+void
+KdSuspend (void)
+{
+    KdCardInfo	    *card;
+    KdScreenInfo    *screen;
+
+    if (kdEnabled)
+    {
+	for (card = kdCardInfo; card; card = card->next)
+	{
+	    for (screen = card->screenList; screen; screen = screen->next)
+		if (screen->mynum == card->selected && screen->pScreen)
+		    KdDisableScreen (screen->pScreen);
+	    if (card->driver && card->cfuncs->restore)
+		(*card->cfuncs->restore) (card);
+	}
+	KdDisableInput ();
+	KdDoSwitchCmd ("suspend");
+    }
+}
+
+void
+KdDisableScreens (void)
+{
+    KdSuspend ();
+    if (kdEnabled)
+    {
+        if (kdOsFuncs->Disable)
+            (*kdOsFuncs->Disable) ();
+	kdEnabled = FALSE;
+    }
+}
+
+Bool
+KdEnableScreen (ScreenPtr pScreen)
+{
+    KdScreenPriv (pScreen);
+
+    if (pScreenPriv->enabled)
+	return TRUE;
+    if(pScreenPriv->card->cfuncs->enable)
+	if (!(*pScreenPriv->card->cfuncs->enable) (pScreen))
+	    return FALSE;
+    pScreenPriv->enabled = TRUE;
+    pScreenPriv->dpmsState = KD_DPMS_NORMAL;
+    pScreenPriv->card->selected = pScreenPriv->screen->mynum;
+    if (!pScreenPriv->screen->softCursor && pScreenPriv->card->cfuncs->enableCursor)
+	(*pScreenPriv->card->cfuncs->enableCursor) (pScreen);
+    if (!pScreenPriv->screen->dumb && pScreenPriv->card->cfuncs->enableAccel)
+	(*pScreenPriv->card->cfuncs->enableAccel) (pScreen);
+    KdEnableColormap (pScreen);
+    SetRootClip (pScreen, TRUE);
+    if (pScreenPriv->card->cfuncs->dpms)
+	(*pScreenPriv->card->cfuncs->dpms) (pScreen, pScreenPriv->dpmsState);
+    return TRUE;
+}
+
+void
+KdResume (void)
+{
+    KdCardInfo	    *card;
+    KdScreenInfo    *screen;
+
+    if (kdEnabled)
+    {
+	KdDoSwitchCmd ("resume");
+	for (card = kdCardInfo; card; card = card->next)
+	{
+	    if(card->cfuncs->preserve)
+		(*card->cfuncs->preserve) (card);
+	    for (screen = card->screenList; screen; screen = screen->next)
+		if (screen->mynum == card->selected && screen->pScreen)
+		    KdEnableScreen (screen->pScreen);
+	}
+	KdEnableInput ();
+	KdReleaseAllKeys ();
+    }
+}
+
+void
+KdEnableScreens (void)
+{
+    if (!kdEnabled)
+    {
+	kdEnabled = TRUE;
+        if (kdOsFuncs->Enable)
+            (*kdOsFuncs->Enable) ();
+    }
+    KdResume ();
+}
+
+void
+KdProcessSwitch (void)
+{
+    if (kdEnabled)
+	KdDisableScreens ();
+    else
+	KdEnableScreens ();
+}
+
+#ifndef _MSC_VER
+void
+AbortDDX(enum ExitCode error)
+{
+    KdDisableScreens ();
+    if (kdOsFuncs)
+    {
+	if (kdEnabled && kdOsFuncs->Disable)
+	    (*kdOsFuncs->Disable) ();
+        if (kdOsFuncs->Fini)
+            (*kdOsFuncs->Fini) ();
+	KdDoSwitchCmd ("stop");
+    }
+
+    if (kdCaughtSignal)
+        OsAbort();
+}
+
+void
+ddxGiveUp (enum ExitCode error)
+{
+    AbortDDX (error);
+}
+#endif
+
+Bool	kdDumbDriver;
+Bool	kdSoftCursor;
+
+char *
+KdParseFindNext (char *cur, char *delim, char *save, char *last)
+{
+    while (*cur && !strchr (delim, *cur))
+    {
+	*save++ = *cur++;
+    }
+    *save = 0;
+    *last = *cur;
+    if (*cur)
+	cur++;
+    return cur;
+}
+
+Rotation
+KdAddRotation (Rotation a, Rotation b)
+{
+    Rotation	rotate = (a & RR_Rotate_All) * (b & RR_Rotate_All);
+    Rotation	reflect = (a & RR_Reflect_All) ^ (b & RR_Reflect_All);
+
+    if (rotate > RR_Rotate_270)
+	rotate /= (RR_Rotate_270 * RR_Rotate_90);
+    return reflect | rotate;
+}
+
+Rotation
+KdSubRotation (Rotation a, Rotation b)
+{
+    Rotation	rotate = (a & RR_Rotate_All) * 16 / (b & RR_Rotate_All);
+    Rotation	reflect = (a & RR_Reflect_All) ^ (b & RR_Reflect_All);
+
+    if (rotate > RR_Rotate_270)
+	rotate /= (RR_Rotate_270 * RR_Rotate_90);
+    return reflect | rotate;
+}
+
+void
+KdParseScreen (KdScreenInfo *screen,
+	       char	    *arg)
+{
+    char    delim;
+    char    save[1024];
+    int	    i;
+    int	    pixels, mm;
+
+    screen->dumb = kdDumbDriver;
+    screen->softCursor = kdSoftCursor;
+    screen->origin = kdOrigin;
+    screen->randr = RR_Rotate_0;
+    screen->width = 0;
+    screen->height = 0;
+    screen->width_mm = 0;
+    screen->height_mm = 0;
+    screen->subpixel_order = kdSubpixelOrder;
+    screen->rate = 0;
+    screen->fb.depth = 0;
+    if (!arg)
+	return;
+    if (strlen (arg) >= sizeof (save))
+	return;
+
+    for (i = 0; i < 2; i++)
+    {
+	arg = KdParseFindNext (arg, "x/@XY", save, &delim);
+	if (!save[0])
+	    return;
+
+	pixels = atoi(save);
+	mm = 0;
+
+	if (delim == '/')
+	{
+	    arg = KdParseFindNext (arg, "x@XY", save, &delim);
+	    if (!save[0])
+		return;
+	    mm = atoi(save);
+	}
+
+	if (i == 0)
+	{
+	    screen->width = pixels;
+	    screen->width_mm = mm;
+	}
+	else
+	{
+	    screen->height = pixels;
+	    screen->height_mm = mm;
+	}
+	if (delim != 'x' && delim != '@' && delim != 'X' && delim != 'Y')
+	    return;
+    }
+
+    kdOrigin.x += screen->width;
+    kdOrigin.y = 0;
+    kdDumbDriver = FALSE;
+    kdSoftCursor = FALSE;
+    kdSubpixelOrder = SubPixelUnknown;
+
+    if (delim == '@')
+    {
+	arg = KdParseFindNext (arg, "xXY", save, &delim);
+	if (save[0])
+	{
+	    int	    rotate = atoi (save);
+	    if (rotate < 45)
+		screen->randr = RR_Rotate_0;
+	    else if (rotate < 135)
+		screen->randr = RR_Rotate_90;
+	    else if (rotate < 225)
+		screen->randr = RR_Rotate_180;
+	    else if (rotate < 315)
+		screen->randr = RR_Rotate_270;
+	    else
+		screen->randr = RR_Rotate_0;
+	}
+    }
+    if (delim == 'X')
+    {
+	arg = KdParseFindNext (arg, "xY", save, &delim);
+	screen->randr |= RR_Reflect_X;
+    }
+
+    if (delim == 'Y')
+    {
+	arg = KdParseFindNext (arg, "xY", save, &delim);
+	screen->randr |= RR_Reflect_Y;
+    }
+
+    arg = KdParseFindNext (arg, "x/,", save, &delim);
+    if (save[0])
+    {
+	screen->fb.depth = atoi(save);
+	if (delim == '/')
+	{
+	    arg = KdParseFindNext (arg, "x,", save, &delim);
+	    if (save[0])
+		screen->fb.bitsPerPixel = atoi (save);
+	}
+	else
+	    screen->fb.bitsPerPixel = 0;
+    }
+
+    if (delim == 'x')
+    {
+	arg = KdParseFindNext (arg, "x", save, &delim);
+	if (save[0])
+	    screen->rate = atoi(save);
+    }
+}
+
+/*
+ * Mouse argument syntax:
+ *
+ *  device,protocol,options...
+ *
+ *  Options are any of:
+ *	1-5	    n button mouse
+ *	2button	    emulate middle button
+ *	{NMO}	    Reorder buttons
+ */
+
+void
+KdParseRgba (char *rgba)
+{
+    if (!strcmp (rgba, "rgb"))
+	kdSubpixelOrder = SubPixelHorizontalRGB;
+    else if (!strcmp (rgba, "bgr"))
+	kdSubpixelOrder = SubPixelHorizontalBGR;
+    else if (!strcmp (rgba, "vrgb"))
+	kdSubpixelOrder = SubPixelVerticalRGB;
+    else if (!strcmp (rgba, "vbgr"))
+	kdSubpixelOrder = SubPixelVerticalBGR;
+    else if (!strcmp (rgba, "none"))
+	kdSubpixelOrder = SubPixelNone;
+    else
+	kdSubpixelOrder = SubPixelUnknown;
+}
+
+void
+KdUseMsg (void)
+{
+    ErrorF("\nTinyX Device Dependent Usage:\n");
+    ErrorF("-screen WIDTH[/WIDTHMM]xHEIGHT[/HEIGHTMM][@ROTATION][X][Y][xDEPTH/BPP[xFREQ]]  Specify screen characteristics\n");
+    ErrorF("-rgba rgb/bgr/vrgb/vbgr/none   Specify subpixel ordering for LCD panels\n");
+    ErrorF("-mouse driver [,n,,options]    Specify the pointer driver and its options (n is the number of buttons)\n");
+    ErrorF("-keybd driver [,,options]      Specify the keyboard driver and its options\n");
+    ErrorF("-zaphod          Disable cursor screen switching\n");
+    ErrorF("-2button         Emulate 3 button mouse\n");
+    ErrorF("-3button         Disable 3 button mouse emulation\n");
+    ErrorF("-rawcoord        Don't transform pointer coordinates on rotation\n");
+    ErrorF("-dumb            Disable hardware acceleration\n");
+    ErrorF("-softCursor      Force software cursor\n");
+    ErrorF("-videoTest       Start the server, pause momentarily and exit\n");
+    ErrorF("-origin X,Y      Locates the next screen in the the virtual screen (Xinerama)\n");
+    ErrorF("-switchCmd       Command to execute on vt switch\n");
+    ErrorF("-zap             Terminate server on Ctrl+Alt+Backspace\n");
+    ErrorF("vtxx             Use virtual terminal xx instead of the next available\n");
+}
+
+int
+KdProcessArgument (int argc, char **argv, int i)
+{
+    KdCardInfo	    *card;
+    KdScreenInfo    *screen;
+
+    if (!strcmp (argv[i], "-screen"))
+    {
+	if ((i+1) < argc)
+	{
+	    card = KdCardInfoLast ();
+	    if (!card)
+	    {
+		InitCard (0);
+		card = KdCardInfoLast ();
+	    }
+	    if (card) {
+		screen = KdScreenInfoAdd (card);
+		KdParseScreen (screen, argv[i+1]);
+	    } else
+		ErrorF("No matching card found!\n");
+	}
+	else
+	    UseMsg ();
+	return 2;
+    }
+    if (!strcmp (argv[i], "-zaphod"))
+    {
+	kdDisableZaphod = TRUE;
+	return 1;
+    }
+    if (!strcmp (argv[i], "-zap"))
+    {
+	kdAllowZap = TRUE;
+	return 1;
+    }
+    if (!strcmp (argv[i], "-3button"))
+    {
+	kdEmulateMiddleButton = FALSE;
+	return 1;
+    }
+    if (!strcmp (argv[i], "-2button"))
+    {
+	kdEmulateMiddleButton = TRUE;
+	return 1;
+    }
+    if (!strcmp (argv[i], "-rawcoord"))
+    {
+	kdRawPointerCoordinates = 1;
+	return 1;
+    }
+    if (!strcmp (argv[i], "-dumb"))
+    {
+	kdDumbDriver = TRUE;
+	return 1;
+    }
+    if (!strcmp (argv[i], "-softCursor"))
+    {
+	kdSoftCursor = TRUE;
+	return 1;
+    }
+    if (!strcmp (argv[i], "-videoTest"))
+    {
+	kdVideoTest = TRUE;
+	return 1;
+    }
+    if (!strcmp (argv[i], "-origin"))
+    {
+	if ((i+1) < argc)
+	{
+	    char    *x = argv[i+1];
+	    char    *y = strchr (x, ',');
+	    if (x)
+		kdOrigin.x = atoi (x);
+	    else
+		kdOrigin.x = 0;
+	    if (y)
+		kdOrigin.y = atoi(y+1);
+	    else
+		kdOrigin.y = 0;
+	}
+	else
+	    UseMsg ();
+	return 2;
+    }
+    if (!strcmp (argv[i], "-rgba"))
+    {
+	if ((i+1) < argc)
+	    KdParseRgba (argv[i+1]);
+	else
+	    UseMsg ();
+	return 2;
+    }
+    if (!strcmp (argv[i], "-switchCmd"))
+    {
+	if ((i+1) < argc)
+	    kdSwitchCmd = argv[i+1];
+	else
+	    UseMsg ();
+	return 2;
+    }
+    if (!strncmp (argv[i], "vt", 2) &&
+	sscanf (argv[i], "vt%2d", &kdVirtualTerminal) == 1)
+    {
+	return 1;
+    }
+    if (!strcmp (argv[i], "-mouse") ||
+        !strcmp (argv[i], "-pointer")) {
+        if (i + 1 >= argc)
+            UseMsg();
+        KdAddConfigPointer(argv[i + 1]);
+	kdHasPointer = TRUE;
+        return 2;
+    }
+    if (!strcmp (argv[i], "-keybd")) {
+        if (i + 1 >= argc)
+            UseMsg();
+        KdAddConfigKeyboard(argv[i + 1]);
+	kdHasKbd = TRUE;
+        return 2;
+    }
+
+    return 0;
+}
+
+/*
+ * These are getting tossed in here until I can think of where
+ * they really belong
+ */
+
+void
+KdOsInit (KdOsFuncs *pOsFuncs)
+{
+    kdOsFuncs = pOsFuncs;
+    if (pOsFuncs)
+    {
+	if (serverGeneration == 1)
+	{
+	    KdDoSwitchCmd ("start");
+            if (pOsFuncs->Init)
+                (*pOsFuncs->Init) ();
+	}
+    }
+}
+
+Bool
+KdAllocatePrivates (ScreenPtr pScreen)
+{
+    KdPrivScreenPtr	pScreenPriv;
+
+    if (kdGeneration != serverGeneration)
+	kdGeneration = serverGeneration;
+
+    if (!dixRegisterPrivateKey(&kdScreenPrivateKeyRec, PRIVATE_SCREEN, 0))
+	return FALSE;
+
+    pScreenPriv = calloc(1, sizeof (*pScreenPriv));
+    if (!pScreenPriv)
+	return FALSE;
+    KdSetScreenPriv (pScreen, pScreenPriv);
+    return TRUE;
+}
+
+Bool
+KdCreateScreenResources (ScreenPtr pScreen)
+{
+    KdScreenPriv(pScreen);
+    KdCardInfo	    *card = pScreenPriv->card;
+    Bool ret;
+
+    pScreen->CreateScreenResources = pScreenPriv->CreateScreenResources;
+    if(pScreen->CreateScreenResources)
+	ret = (*pScreen->CreateScreenResources) (pScreen);
+    else
+	ret= -1;
+    pScreenPriv->CreateScreenResources = pScreen->CreateScreenResources;
+    pScreen->CreateScreenResources = KdCreateScreenResources;
+    if (ret && card->cfuncs->createRes)
+	ret = (*card->cfuncs->createRes) (pScreen);
+    return ret;
+}
+
+Bool
+KdCloseScreen (int index, ScreenPtr pScreen)
+{
+    KdScreenPriv(pScreen);
+    KdScreenInfo    *screen = pScreenPriv->screen;
+    KdCardInfo	    *card = pScreenPriv->card;
+    Bool	    ret;
+
+    pScreenPriv->closed = TRUE;
+    pScreen->CloseScreen = pScreenPriv->CloseScreen;
+    if(pScreen->CloseScreen)
+        ret = (*pScreen->CloseScreen) (index, pScreen);
+    else
+	ret = TRUE;
+
+    if (pScreenPriv->dpmsState != KD_DPMS_NORMAL)
+	(*card->cfuncs->dpms) (pScreen, KD_DPMS_NORMAL);
+
+    if (screen->mynum == card->selected)
+	KdDisableScreen (pScreen);
+
+    /*
+     * Restore video hardware when last screen is closed
+     */
+    if (screen == card->screenList)
+    {
+	if (kdEnabled && card->cfuncs->restore)
+	    (*card->cfuncs->restore) (card);
+    }
+
+    if (!pScreenPriv->screen->dumb && card->cfuncs->finiAccel)
+	(*card->cfuncs->finiAccel) (pScreen);
+
+    if (!pScreenPriv->screen->softCursor && card->cfuncs->finiCursor)
+	(*card->cfuncs->finiCursor) (pScreen);
+
+    if(card->cfuncs->scrfini)
+        (*card->cfuncs->scrfini) (screen);
+
+    /*
+     * Clean up card when last screen is closed, DIX closes them in
+     * reverse order, thus we check for when the first in the list is closed
+     */
+    if (screen == card->screenList)
+    {
+	if(card->cfuncs->cardfini)
+	    (*card->cfuncs->cardfini) (card);
+	/*
+	 * Clean up OS when last card is closed
+	 */
+	if (card == kdCardInfo)
+	{
+	    if (kdEnabled)
+	    {
+		kdEnabled = FALSE;
+		if(kdOsFuncs->Disable)
+		    (*kdOsFuncs->Disable) ();
+	    }
+	}
+    }
+
+    pScreenPriv->screen->pScreen = 0;
+
+    free((pointer) pScreenPriv);
+    return ret;
+}
+
+Bool
+KdSaveScreen (ScreenPtr pScreen, int on)
+{
+    KdScreenPriv(pScreen);
+    int	    dpmsState;
+
+    if (!pScreenPriv->card->cfuncs->dpms)
+	return FALSE;
+
+    dpmsState = pScreenPriv->dpmsState;
+    switch (on) {
+    case SCREEN_SAVER_OFF:
+	dpmsState = KD_DPMS_NORMAL;
+	break;
+    case SCREEN_SAVER_ON:
+	if (dpmsState == KD_DPMS_NORMAL)
+	    dpmsState = KD_DPMS_NORMAL+1;
+	break;
+    case SCREEN_SAVER_CYCLE:
+	if (dpmsState < KD_DPMS_MAX)
+	    dpmsState++;
+	break;
+    case SCREEN_SAVER_FORCER:
+	break;
+    }
+    if (dpmsState != pScreenPriv->dpmsState)
+    {
+	if (pScreenPriv->enabled)
+	    (*pScreenPriv->card->cfuncs->dpms) (pScreen, dpmsState);
+	pScreenPriv->dpmsState = dpmsState;
+    }
+    return TRUE;
+}
+
+static Bool
+KdCreateWindow (WindowPtr pWin)
+{
+#ifndef PHOENIX
+    if (!pWin->parent)
+    {
+	KdScreenPriv(pWin->drawable.pScreen);
+
+	if (!pScreenPriv->enabled)
+	{
+	    RegionEmpty(&pWin->borderClip);
+	    RegionBreak(&pWin->clipList);
+	}
+    }
+#endif
+    return fbCreateWindow (pWin);
+}
+
+void
+KdSetSubpixelOrder (ScreenPtr pScreen, Rotation randr)
+{
+    KdScreenPriv(pScreen);
+    KdScreenInfo	*screen = pScreenPriv->screen;
+    int			subpixel_order = screen->subpixel_order;
+    Rotation		subpixel_dir;
+    int			i;
+
+    static struct {
+	int	    subpixel_order;
+	Rotation    direction;
+    } orders[] = {
+	{ SubPixelHorizontalRGB, 	RR_Rotate_0 },
+	{ SubPixelHorizontalBGR,	RR_Rotate_180 },
+	{ SubPixelVerticalRGB,		RR_Rotate_270 },
+	{ SubPixelVerticalBGR,		RR_Rotate_90 },
+    };
+
+    static struct {
+	int	bit;
+	int	normal;
+	int	reflect;
+    } reflects[] = {
+	{ RR_Reflect_X, SubPixelHorizontalRGB,	SubPixelHorizontalBGR },
+	{ RR_Reflect_X, SubPixelHorizontalBGR,	SubPixelHorizontalRGB },
+	{ RR_Reflect_Y, SubPixelVerticalRGB,	SubPixelVerticalBGR },
+	{ RR_Reflect_Y, SubPixelVerticalRGB,	SubPixelVerticalRGB },
+    };
+
+    /* map subpixel to direction */
+    for (i = 0; i < 4; i++)
+	if (orders[i].subpixel_order == subpixel_order)
+	    break;
+    if (i < 4)
+    {
+	subpixel_dir = KdAddRotation (randr & RR_Rotate_All, orders[i].direction);
+
+	/* map back to subpixel order */
+	for (i = 0; i < 4; i++)
+	    if (orders[i].direction & subpixel_dir)
+	    {
+		subpixel_order = orders[i].subpixel_order;
+		break;
+	    }
+	/* reflect */
+	for (i = 0; i < 4; i++)
+	    if ((randr & reflects[i].bit) &&
+		reflects[i].normal == subpixel_order)
+	    {
+		subpixel_order = reflects[i].reflect;
+		break;
+	    }
+    }
+    PictureSetSubpixelOrder (pScreen, subpixel_order);
+}
+
+/* Pass through AddScreen, which doesn't take any closure */
+static KdScreenInfo *kdCurrentScreen;
+
+Bool
+KdScreenInit(int index, ScreenPtr pScreen, int argc, char **argv)
+{
+    KdScreenInfo	*screen = kdCurrentScreen;
+    KdCardInfo		*card = screen->card;
+    KdPrivScreenPtr	pScreenPriv;
+    /*
+     * note that screen->fb is set up for the nominal orientation
+     * of the screen; that means if randr is rotated, the values
+     * there should reflect a rotated frame buffer (or shadow).
+     */
+    Bool		rotated = (screen->randr & (RR_Rotate_90|RR_Rotate_270)) != 0;
+    int			width, height, *width_mmp, *height_mmp;
+
+    KdAllocatePrivates (pScreen);
+
+    pScreenPriv = KdGetScreenPriv(pScreen);
+
+    if (!rotated)
+    {
+	width = screen->width;
+	height = screen->height;
+	width_mmp = &screen->width_mm;
+	height_mmp = &screen->height_mm;
+    }
+    else
+    {
+	width = screen->height;
+	height = screen->width;
+	width_mmp = &screen->height_mm;
+	height_mmp = &screen->width_mm;
+    }
+    screen->pScreen = pScreen;
+    pScreenPriv->screen = screen;
+    pScreenPriv->card = card;
+    pScreenPriv->bytesPerPixel = screen->fb.bitsPerPixel >> 3;
+    pScreenPriv->dpmsState = KD_DPMS_NORMAL;
+    pScreen->x = screen->origin.x;
+    pScreen->y = screen->origin.y;
+
+    if (!monitorResolution)
+	monitorResolution = 75;
+    /*
+     * This is done in this order so that backing store wraps
+     * our GC functions; fbFinishScreenInit initializes MI
+     * backing store
+     */
+    if (!fbSetupScreen (pScreen,
+			screen->fb.frameBuffer,
+			width, height,
+			monitorResolution, monitorResolution,
+			screen->fb.pixelStride,
+			screen->fb.bitsPerPixel))
+    {
+	return FALSE;
+    }
+
+    /*
+     * Set colormap functions
+     */
+    pScreen->InstallColormap	= KdInstallColormap;
+    pScreen->UninstallColormap	= KdUninstallColormap;
+    pScreen->ListInstalledColormaps = KdListInstalledColormaps;
+    pScreen->StoreColors	= KdStoreColors;
+
+    pScreen->SaveScreen		= KdSaveScreen;
+    pScreen->CreateWindow	= KdCreateWindow;
+
+    if (!fbFinishScreenInit (pScreen,
+			     screen->fb.frameBuffer,
+			     width, height,
+			     monitorResolution, monitorResolution,
+			     screen->fb.pixelStride,
+			     screen->fb.bitsPerPixel))
+    {
+	return FALSE;
+    }
+
+    /*
+     * Fix screen sizes; for some reason mi takes dpi instead of mm.
+     * Rounding errors are annoying
+     */
+    if (*width_mmp)
+	pScreen->mmWidth = *width_mmp;
+    else
+	*width_mmp = pScreen->mmWidth;
+    if (*height_mmp)
+	pScreen->mmHeight = *height_mmp;
+    else
+	*height_mmp = pScreen->mmHeight;
+
+    /*
+     * Plug in our own block/wakeup handlers.
+     * miScreenInit installs NoopDDA in both places
+     */
+    pScreen->BlockHandler	= KdBlockHandler;
+    pScreen->WakeupHandler	= KdWakeupHandler;
+
+    if (!fbPictureInit (pScreen, 0, 0))
+	return FALSE;
+    if (card->cfuncs->initScreen)
+	if (!(*card->cfuncs->initScreen) (pScreen))
+	    return FALSE;
+
+    if (!screen->dumb && card->cfuncs->initAccel)
+	if (!(*card->cfuncs->initAccel) (pScreen))
+	    screen->dumb = TRUE;
+
+    if (card->cfuncs->finishInitScreen)
+	if (!(*card->cfuncs->finishInitScreen) (pScreen))
+	    return FALSE;
+
+#if 0
+    fbInitValidateTree (pScreen);
+#endif
+
+    /*
+     * Wrap CloseScreen, the order now is:
+     *	KdCloseScreen
+     *	miBSCloseScreen
+     *	fbCloseScreen
+     */
+    pScreenPriv->CloseScreen = pScreen->CloseScreen;
+    pScreen->CloseScreen = KdCloseScreen;
+
+    pScreenPriv->CreateScreenResources = pScreen->CreateScreenResources;
+    pScreen->CreateScreenResources = KdCreateScreenResources;
+
+    if (screen->softCursor ||
+	!card->cfuncs->initCursor ||
+	!(*card->cfuncs->initCursor) (pScreen))
+    {
+	/* Use MI for cursor display and event queueing. */
+	screen->softCursor = TRUE;
+	miDCInitialize(pScreen, &kdPointerScreenFuncs);
+    }
+
+
+    if (!fbCreateDefColormap (pScreen))
+    {
+	return FALSE;
+    }
+
+    KdSetSubpixelOrder (pScreen, screen->randr);
+
+    /*
+     * Enable the hardware
+     */
+    if (!kdEnabled)
+    {
+	kdEnabled = TRUE;
+	if(kdOsFuncs->Enable)
+	    (*kdOsFuncs->Enable) ();
+    }
+
+    if (screen->mynum == card->selected)
+    {
+	if(card->cfuncs->preserve)
+	    (*card->cfuncs->preserve) (card);
+	if(card->cfuncs->enable)
+	    if (!(*card->cfuncs->enable) (pScreen))
+		return FALSE;
+	pScreenPriv->enabled = TRUE;
+	if (!screen->softCursor && card->cfuncs->enableCursor)
+	    (*card->cfuncs->enableCursor) (pScreen);
+	KdEnableColormap (pScreen);
+	if (!screen->dumb && card->cfuncs->enableAccel)
+	    (*card->cfuncs->enableAccel) (pScreen);
+    }
+
+    return TRUE;
+}
+
+void
+KdInitScreen (ScreenInfo    *pScreenInfo,
+	      KdScreenInfo  *screen,
+	      int	    argc,
+	      char	    **argv)
+{
+    KdCardInfo	*card = screen->card;
+
+    (*card->cfuncs->scrinit) (screen);
+
+    if (!card->cfuncs->initAccel)
+	screen->dumb = TRUE;
+    if (!card->cfuncs->initCursor)
+	screen->softCursor = TRUE;
+}
+
+static Bool
+KdSetPixmapFormats (ScreenInfo	*pScreenInfo)
+{
+    CARD8	    depthToBpp[33];	/* depth -> bpp map */
+    KdCardInfo	    *card;
+    KdScreenInfo    *screen;
+    int		    i;
+    int		    bpp;
+    PixmapFormatRec *format;
+
+    for (i = 1; i <= 32; i++)
+	depthToBpp[i] = 0;
+
+    /*
+     * Generate mappings between bitsPerPixel and depth,
+     * also ensure that all screens comply with protocol
+     * restrictions on equivalent formats for the same
+     * depth on different screens
+     */
+    for (card = kdCardInfo; card; card = card->next)
+    {
+	for (screen = card->screenList; screen; screen = screen->next)
+	{
+	    bpp = screen->fb.bitsPerPixel;
+	    if (bpp == 24)
+		bpp = 32;
+	    if (!depthToBpp[screen->fb.depth])
+		depthToBpp[screen->fb.depth] = bpp;
+	    else if (depthToBpp[screen->fb.depth] != bpp)
+		return FALSE;
+	}
+    }
+
+    /*
+     * Fill in additional formats
+     */
+    for (i = 0; i < NUM_KD_DEPTHS; i++)
+	if (!depthToBpp[kdDepths[i].depth])
+	    depthToBpp[kdDepths[i].depth] = kdDepths[i].bpp;
+
+    pScreenInfo->imageByteOrder     = IMAGE_BYTE_ORDER;
+    pScreenInfo->bitmapScanlineUnit = BITMAP_SCANLINE_UNIT;
+    pScreenInfo->bitmapScanlinePad  = BITMAP_SCANLINE_PAD;
+    pScreenInfo->bitmapBitOrder     = BITMAP_BIT_ORDER;
+
+    pScreenInfo->numPixmapFormats = 0;
+
+    for (i = 1; i <= 32; i++)
+    {
+	if (depthToBpp[i])
+	{
+	    format = &pScreenInfo->formats[pScreenInfo->numPixmapFormats++];
+	    format->depth = i;
+	    format->bitsPerPixel = depthToBpp[i];
+	    format->scanlinePad = BITMAP_SCANLINE_PAD;
+	}
+    }
+
+    return TRUE;
+}
+
+static void
+KdAddScreen (ScreenInfo	    *pScreenInfo,
+	     KdScreenInfo   *screen,
+	     int	    argc,
+	     char	    **argv)
+{
+    int	    i;
+    /*
+     * Fill in fb visual type masks for this screen
+     */
+    for (i = 0; i < pScreenInfo->numPixmapFormats; i++)
+    {
+	unsigned long	visuals;
+	Pixel		rm, gm, bm;
+
+	visuals = 0;
+	rm = gm = bm = 0;
+	if (pScreenInfo->formats[i].depth == screen->fb.depth)
+	{
+	    visuals = screen->fb.visuals;
+	    rm = screen->fb.redMask;
+	    gm = screen->fb.greenMask;
+	    bm = screen->fb.blueMask;
+	}
+	fbSetVisualTypesAndMasks (pScreenInfo->formats[i].depth,
+				  visuals,
+				  8,
+				  rm, gm, bm);
+    }
+
+    kdCurrentScreen = screen;
+
+    AddScreen (KdScreenInit, argc, argv);
+}
+
+#if 0 /* This function is not used currently */
+
+int
+KdDepthToFb (ScreenPtr	pScreen, int depth)
+{
+    KdScreenPriv(pScreen);
+
+    for (fb = 0; fb <= KD_MAX_FB && pScreenPriv->screen->fb.frameBuffer; fb++)
+	if (pScreenPriv->screen->fb.depth == depth)
+	    return fb;
+}
+
+#endif
+
+static int
+KdSignalWrapper (int signum)
+{
+    kdCaughtSignal = TRUE;
+    return 1; /* use generic OS layer cleanup & abort */
+}
+
+void
+KdInitOutput (ScreenInfo    *pScreenInfo,
+	      int	    argc,
+	      char	    **argv)
+{
+    KdCardInfo	    *card;
+    KdScreenInfo    *screen;
+
+    if (!kdCardInfo)
+    {
+	InitCard (0);
+	if (!(card = KdCardInfoLast ()))
+	    FatalError("No matching cards found!\n");
+	screen = KdScreenInfoAdd (card);
+	KdParseScreen (screen, 0);
+    }
+    /*
+     * Initialize all of the screens for all of the cards
+     */
+    for (card = kdCardInfo; card; card = card->next)
+    {
+	int ret=1;
+	if(card->cfuncs->cardinit)
+		ret=(*card->cfuncs->cardinit) (card);
+	if (ret)
+	{
+	    for (screen = card->screenList; screen; screen = screen->next)
+		KdInitScreen (pScreenInfo, screen, argc, argv);
+	}
+    }
+
+    /*
+     * Merge the various pixmap formats together, this can fail
+     * when two screens share depth but not bitsPerPixel
+     */
+    if (!KdSetPixmapFormats (pScreenInfo))
+	return;
+
+    /*
+     * Add all of the screens
+     */
+    for (card = kdCardInfo; card; card = card->next)
+	for (screen = card->screenList; screen; screen = screen->next)
+	    KdAddScreen (pScreenInfo, screen, argc, argv);
+
+    OsRegisterSigWrapper(KdSignalWrapper);
+}
+
+#ifndef _MSC_VER
+void
+OsVendorFatalError(void)
+{
+}
+
+int
+DPMSSet(ClientPtr client, int level)
+{
+    return Success;
+}
+
+Bool
+DPMSSupported (void)
+{
+    return FALSE;
+}
+#endif
diff --git a/xorg-server/hw/kdrive/src/kdrive.h b/xorg-server/hw/kdrive/src/kdrive.h
index 4d0201fa1..00f07df41 100644
--- a/xorg-server/hw/kdrive/src/kdrive.h
+++ b/xorg-server/hw/kdrive/src/kdrive.h
@@ -1,627 +1,627 @@
-/*

- * Copyright © 1999 Keith Packard

- *

- * 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 Keith Packard not be used in

- * advertising or publicity pertaining to distribution of the software without

- * specific, written prior permission.  Keith Packard makes no

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

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

- *

- * KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,

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

- * EVENT SHALL KEITH PACKARD 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.

- */

-

-#ifndef _KDRIVE_H_

-#define _KDRIVE_H_

-

-#include <stdio.h>

-#include <string.h>

-#include <X11/X.h>

-#include <X11/Xproto.h>

-#include <X11/Xos.h>

-#include "scrnintstr.h"

-#include "pixmapstr.h"

-#include "windowstr.h"

-#include "servermd.h"

-#include "mibstore.h"

-#include "colormapst.h"

-#include "gcstruct.h"

-#include "input.h"

-#include "mipointer.h"

-#include "mi.h"

-#include "dix.h"

-#include "fb.h"

-#include "fboverlay.h"

-#include "shadow.h"

-#include "randrstr.h"

-#include "globals.h"

-

-#include "xkbstr.h"

-

-#define KD_DPMS_NORMAL	    0

-#define KD_DPMS_STANDBY	    1

-#define KD_DPMS_SUSPEND	    2

-#define KD_DPMS_POWERDOWN   3

-#define KD_DPMS_MAX	    KD_DPMS_POWERDOWN

-

-typedef int Status;

-

-typedef struct _KdCardInfo {

-    struct _KdCardFuncs	    *cfuncs;

-    void		    *closure;

-    void		    *driver;

-    struct _KdScreenInfo    *screenList;

-    int			    selected;

-    struct _KdCardInfo	    *next;

-} KdCardInfo;

-

-extern KdCardInfo	*kdCardInfo;

-

-/*

- * Configuration information per X screen

- */

-typedef struct _KdFrameBuffer {

-    CARD8	*frameBuffer;

-    int		depth;

-    int		bitsPerPixel;

-    int		pixelStride;

-    int		byteStride;

-    Bool	shadow;

-    unsigned long   visuals;

-    Pixel       redMask, greenMask, blueMask;

-    void	*closure;

-} KdFrameBuffer;

-

-#define RR_Rotate_All	(RR_Rotate_0|RR_Rotate_90|RR_Rotate_180|RR_Rotate_270)

-#define RR_Reflect_All	(RR_Reflect_X|RR_Reflect_Y)

-

-typedef struct _KdScreenInfo {

-    struct _KdScreenInfo    *next;

-    KdCardInfo	*card;

-    ScreenPtr	pScreen;

-    void	*driver;

-    Rotation	randr;	/* rotation and reflection */

-    int		width;

-    int		height;

-    int		rate;

-    int		width_mm;

-    int		height_mm;

-    int		subpixel_order;

-    Bool        dumb;

-    Bool        softCursor;

-    int		mynum;

-    DDXPointRec	origin;

-    KdFrameBuffer   fb;

-} KdScreenInfo;

-

-typedef struct _KdCardFuncs {

-    Bool	(*cardinit) (KdCardInfo *); /* detect and map device */

-    Bool	(*scrinit) (KdScreenInfo *);/* initialize screen information */

-    Bool	(*initScreen) (ScreenPtr);  /* initialize ScreenRec */

-    Bool	(*finishInitScreen) (ScreenPtr pScreen);

-    Bool	(*createRes) (ScreenPtr);   /* create screen resources */

-    void	(*preserve) (KdCardInfo *); /* save graphics card state */

-    Bool        (*enable) (ScreenPtr);      /* set up for rendering */

-    Bool	(*dpms) (ScreenPtr, int);   /* set DPMS screen saver */

-    void        (*disable) (ScreenPtr);     /* turn off rendering */

-    void	(*restore) (KdCardInfo *);  /* restore graphics card state */

-    void	(*scrfini) (KdScreenInfo *);/* close down screen */

-    void        (*cardfini) (KdCardInfo *); /* close down */

-

-    Bool        (*initCursor) (ScreenPtr);      /* detect and map cursor */

-    void        (*enableCursor) (ScreenPtr);    /* enable cursor */

-    void        (*disableCursor) (ScreenPtr);   /* disable cursor */

-    void        (*finiCursor) (ScreenPtr);      /* close down */

-    void        (*recolorCursor) (ScreenPtr, int, xColorItem *);

-

-    Bool        (*initAccel) (ScreenPtr);

-    void        (*enableAccel) (ScreenPtr);

-    void        (*disableAccel) (ScreenPtr);

-    void        (*finiAccel) (ScreenPtr);

-

-    void        (*getColors) (ScreenPtr, int, xColorItem *);

-    void        (*putColors) (ScreenPtr, int, xColorItem *);

-

-} KdCardFuncs;

-

-#define KD_MAX_PSEUDO_DEPTH 8

-#define KD_MAX_PSEUDO_SIZE	    (1 << KD_MAX_PSEUDO_DEPTH)

-

-typedef struct {

-    KdScreenInfo    *screen;

-    KdCardInfo	    *card;

-

-    Bool	    enabled;

-    Bool	    closed;

-    int		    bytesPerPixel;

-

-    int		    dpmsState;

-

-    ColormapPtr     pInstalledmap;                    /* current colormap */

-    xColorItem      systemPalette[KD_MAX_PSEUDO_SIZE];/* saved windows colors */

-

-    CreateScreenResourcesProcPtr    CreateScreenResources;

-    CloseScreenProcPtr  CloseScreen;

-} KdPrivScreenRec, *KdPrivScreenPtr;

-

-typedef enum _kdPointerState {

-    start,

-    button_1_pend,

-    button_1_down,

-    button_2_down,

-    button_3_pend,

-    button_3_down,

-    synth_2_down_13,

-    synth_2_down_3,

-    synth_2_down_1,

-    num_input_states

-} KdPointerState;

-

-#define KD_MAX_BUTTON  32

-

-#define KD_KEYBOARD 1

-#define KD_MOUSE 2

-#define KD_TOUCHSCREEN 3

-

-typedef struct _KdPointerInfo KdPointerInfo;

-

-typedef struct _KdPointerDriver {

-    char                    *name;

-    Status                  (*Init)    (KdPointerInfo *);

-    Status                  (*Enable)  (KdPointerInfo *);

-    void                    (*Disable) (KdPointerInfo *);

-    void                    (*Fini)    (KdPointerInfo *);

-    struct _KdPointerDriver *next;

-} KdPointerDriver;

-

-struct _KdPointerInfo {

-    DeviceIntPtr          dixdev;

-    char                  *name;

-    char                  *path;

-    char                  *protocol;

-    InputOption           *options;

-    int                   inputClass;

-

-    CARD8                 map[KD_MAX_BUTTON + 1];

-    int                   nButtons;

-    int                   nAxes;

-

-    Bool                  emulateMiddleButton;

-    unsigned long         emulationTimeout;

-    int                   emulationDx, emulationDy;

-

-    Bool                  timeoutPending;

-    KdPointerState        mouseState;

-    Bool                  eventHeld;

-    struct {

-        int type;

-        int x;

-        int y;

-        int z;

-        int flags;

-        int absrel;

-    } heldEvent;

-    unsigned char         buttonState;

-    Bool                  transformCoordinates;

-    int                   pressureThreshold;

-

-    KdPointerDriver       *driver;

-    void                  *driverPrivate;

-

-    struct _KdPointerInfo *next;

-};

-

-extern int KdCurScreen;

-

-void KdAddPointerDriver (KdPointerDriver *driver);

-void KdRemovePointerDriver (KdPointerDriver *driver);

-KdPointerInfo *KdNewPointer (void);

-void KdFreePointer (KdPointerInfo *);

-int KdAddPointer (KdPointerInfo *ki);

-int KdAddConfigPointer (char *pointer);

-void KdRemovePointer (KdPointerInfo *ki);

-

-

-#define KD_KEY_COUNT 248

-#define KD_MIN_KEYCODE  8

-#define KD_MAX_KEYCODE  255

-#define KD_MAX_WIDTH    4

-#define KD_MAX_LENGTH   (KD_MAX_KEYCODE - KD_MIN_KEYCODE + 1)

-

-typedef struct {

-    KeySym modsym;

-    int    modbit;

-} KdKeySymModsRec;

-

-typedef struct _KdKeyboardInfo KdKeyboardInfo;

-

-typedef struct _KdKeyboardDriver {

-    char                  *name;

-    Bool                  (*Init)    (KdKeyboardInfo *);

-    Bool                  (*Enable)  (KdKeyboardInfo *);

-    void                  (*Leds)    (KdKeyboardInfo *, int);

-    void                  (*Bell)    (KdKeyboardInfo *, int, int, int);

-    void                  (*Disable) (KdKeyboardInfo *);

-    void                  (*Fini)    (KdKeyboardInfo *);

-    struct _KdKeyboardDriver *next;

-} KdKeyboardDriver;

-

-struct _KdKeyboardInfo {

-    struct _KdKeyboardInfo *next;

-    DeviceIntPtr        dixdev;

-    void                *closure;

-    char                *name;

-    char                *path;

-    int                 inputClass;

-    char                *xkbRules;

-    char                *xkbModel;

-    char                *xkbLayout;

-    char                *xkbVariant;

-    char                *xkbOptions;

-    int                 LockLed;

-

-    int                 minScanCode;

-    int                 maxScanCode;

-

-    int                 leds;

-    int                 bellPitch;

-    int                 bellDuration;

-    InputOption         *options;

-

-    KdKeyboardDriver    *driver;

-    void                *driverPrivate;

-};

-

-void KdAddKeyboardDriver (KdKeyboardDriver *driver);

-void KdRemoveKeyboardDriver (KdKeyboardDriver *driver);

-KdKeyboardInfo *KdNewKeyboard (void);

-void KdFreeKeyboard (KdKeyboardInfo *ki);

-int KdAddConfigKeyboard (char *pointer);

-int KdAddKeyboard (KdKeyboardInfo *ki);

-void KdRemoveKeyboard (KdKeyboardInfo *ki);

-

-typedef struct _KdOsFuncs {

-    int		    (*Init) (void);

-    void	    (*Enable) (void);

-    Bool	    (*SpecialKey) (KeySym);

-    void	    (*Disable) (void);

-    void	    (*Fini) (void);

-    void	    (*pollEvents) (void);

-    void            (*Bell) (int, int, int);

-} KdOsFuncs;

-

-typedef enum _KdSyncPolarity {

-    KdSyncNegative, KdSyncPositive

-} KdSyncPolarity;

-

-typedef struct _KdMonitorTiming {

-    /* label */

-    int		    horizontal;

-    int		    vertical;

-    int		    rate;

-    /* pixel clock */

-    int		    clock;  /* in KHz */

-    /* horizontal timing */

-    int		    hfp;    /* front porch */

-    int		    hbp;    /* back porch */

-    int		    hblank; /* blanking */

-    KdSyncPolarity  hpol;   /* polarity */

-    /* vertical timing */

-    int		    vfp;    /* front porch */

-    int		    vbp;    /* back porch */

-    int		    vblank; /* blanking */

-    KdSyncPolarity  vpol;   /* polarity */

-} KdMonitorTiming;

-

-extern const KdMonitorTiming	kdMonitorTimings[];

-extern const int		kdNumMonitorTimings;

-

-typedef struct _KdPointerMatrix {

-    int	    matrix[2][3];

-} KdPointerMatrix;

-

-/*

- * This is the only completely portable way to

- * compute this info.

- */

-

-#ifndef BitsPerPixel

-#define BitsPerPixel(d) (\

-    PixmapWidthPaddingInfo[d].notPower2 ? \

-    (PixmapWidthPaddingInfo[d].bytesPerPixel * 8) : \

-    ((1 << PixmapWidthPaddingInfo[d].padBytesLog2) * 8 / \

-    (PixmapWidthPaddingInfo[d].padRoundUp+1)))

-#endif

-

-extern DevPrivateKeyRec	kdScreenPrivateKeyRec;

-#define kdScreenPrivateKey (&kdScreenPrivateKeyRec)

-

-extern unsigned long	kdGeneration;

-extern Bool		kdEnabled;

-extern Bool		kdSwitchPending;

-extern Bool		kdEmulateMiddleButton;

-extern Bool		kdDisableZaphod;

-extern Bool		kdAllowZap;

-extern int		kdVirtualTerminal;

-extern char		*kdSwitchCmd;

-extern KdOsFuncs	*kdOsFuncs;

-

-#define KdGetScreenPriv(pScreen) ((KdPrivScreenPtr) \

-    dixLookupPrivate(&(pScreen)->devPrivates, kdScreenPrivateKey))

-#define KdSetScreenPriv(pScreen,v) \

-    dixSetPrivate(&(pScreen)->devPrivates, kdScreenPrivateKey, v)

-#define KdScreenPriv(pScreen) KdPrivScreenPtr pScreenPriv = KdGetScreenPriv(pScreen)

-

-/* kcmap.c */

-void

-KdSetColormap (ScreenPtr pScreen);

-

-void

-KdEnableColormap (ScreenPtr pScreen);

-

-void

-KdDisableColormap (ScreenPtr pScreen);

-

-void

-KdInstallColormap (ColormapPtr pCmap);

-

-void

-KdUninstallColormap (ColormapPtr pCmap);

-

-int

-KdListInstalledColormaps (ScreenPtr pScreen, Colormap *pCmaps);

-

-void

-KdStoreColors (ColormapPtr pCmap, int ndef, xColorItem *pdefs);

-

-/* kdrive.c */

-extern miPointerScreenFuncRec kdPointerScreenFuncs;

-

-void

-KdDisableScreen (ScreenPtr pScreen);

-

-void

-KdDisableScreens (void);

-

-Bool

-KdEnableScreen (ScreenPtr pScreen);

-

-void

-KdEnableScreens (void);

-

-void

-KdSuspend (void);

-

-void

-KdResume (void);

-

-void

-KdProcessSwitch (void);

-

-Rotation

-KdAddRotation (Rotation a, Rotation b);

-

-Rotation

-KdSubRotation (Rotation a, Rotation b);

-

-void

-KdParseScreen (KdScreenInfo *screen,

-	       char	    *arg);

-

-KdPointerInfo *

-KdParsePointer (char *arg);

-

-KdKeyboardInfo *

-KdParseKeyboard (char *arg);

-

-char *

-KdParseFindNext (char *cur, char *delim, char *save, char *last);

-

-void

-KdParseRgba (char *rgba);

-

-void

-KdUseMsg (void);

-

-int

-KdProcessArgument (int argc, char **argv, int i);

-

-void

-KdOsInit (KdOsFuncs *pOsFuncs);

-

-void

-KdOsAddInputDrivers (void);

-

-Bool

-KdAllocatePrivates (ScreenPtr pScreen);

-

-Bool

-KdCreateScreenResources (ScreenPtr pScreen);

-

-Bool

-KdCloseScreen (int index, ScreenPtr pScreen);

-

-Bool

-KdSaveScreen (ScreenPtr pScreen, int on);

-

-Bool

-KdScreenInit(int index, ScreenPtr pScreen, int argc, char **argv);

-

-void

-KdInitScreen (ScreenInfo    *pScreenInfo,

-	      KdScreenInfo  *screen,

-	      int	    argc,

-	      char	    **argv);

-

-void

-KdInitCard (ScreenInfo	    *pScreenInfo,

-	    KdCardInfo	    *card,

-	    int		    argc,

-	    char	    **argv);

-

-void

-KdInitOutput (ScreenInfo    *pScreenInfo,

-	      int	    argc,

-	      char	    **argv);

-

-void

-KdSetSubpixelOrder (ScreenPtr pScreen, Rotation randr);

-

-void

-KdBacktrace (int signum);

-

-/* kinfo.c */

-KdCardInfo *

-KdCardInfoAdd (KdCardFuncs  *funcs,

-	       void	    *closure);

-

-KdCardInfo *

-KdCardInfoLast (void);

-

-void

-KdCardInfoDispose (KdCardInfo *ci);

-

-KdScreenInfo *

-KdScreenInfoAdd (KdCardInfo *ci);

-

-void

-KdScreenInfoDispose (KdScreenInfo *si);

-

-

-/* kinput.c */

-void

-KdInitInput(void);

-void

-KdCloseInput(void);

-

-void

-KdAddPointerDriver(KdPointerDriver *);

-

-void

-KdAddKeyboardDriver(KdKeyboardDriver *);

-

-Bool

-KdRegisterFd (int fd, void (*read) (int fd, void *closure), void *closure);

-

-void

-KdUnregisterFds (void *closure, Bool do_close);

-

-void

-KdUnregisterFd (void *closure, int fd, Bool do_close);

-

-void

-KdEnqueueKeyboardEvent(KdKeyboardInfo *ki, unsigned char scan_code,

-                    unsigned char is_up);

-

-#define KD_BUTTON_1	0x01

-#define KD_BUTTON_2	0x02

-#define KD_BUTTON_3	0x04

-#define KD_BUTTON_4	0x08

-#define KD_BUTTON_5	0x10

-#define KD_BUTTON_8	0x80

-#define KD_MOUSE_DELTA	0x80000000

-

-void

-KdEnqueuePointerEvent(KdPointerInfo *pi, unsigned long flags, int rx, int ry,

-                      int rz);

-

-void

-_KdEnqueuePointerEvent(KdPointerInfo *pi, int type, int x, int y, int z,

-                       int b, int absrel, Bool force);

-

-void

-KdReleaseAllKeys (void);

-

-void

-KdSetLed (KdKeyboardInfo *ki, int led, Bool on);

-

-void

-KdSetPointerMatrix (KdPointerMatrix *pointer);

-

-void

-KdComputePointerMatrix (KdPointerMatrix *pointer, Rotation randr, int width, int height);

-

-void

-KdScreenToPointerCoords (int *x, int *y);

-

-void

-KdBlockHandler (int		screen,

-		pointer		blockData,

-		pointer		timeout,

-		pointer		readmask);

-

-void

-KdWakeupHandler (int		screen,

-		 pointer    	data,

-		 unsigned long	result,

-		 pointer	readmask);

-

-void

-KdDisableInput (void);

-

-void

-KdEnableInput (void);

-

-void

-ProcessInputEvents (void);

-

-void

-KdRingBell (KdKeyboardInfo      *ki,

-            int                 volume,

-            int                 pitch,

-            int                 duration);

-

-/* kmode.c */

-const KdMonitorTiming *

-KdFindMode (KdScreenInfo    *screen,

-	    Bool	    (*supported) (KdScreenInfo *,

-					  const KdMonitorTiming *));

-

-Bool

-KdTuneMode (KdScreenInfo    *screen,

-	    Bool	    (*usable) (KdScreenInfo *),

-	    Bool	    (*supported) (KdScreenInfo *,

-					  const KdMonitorTiming *));

-

-#ifdef RANDR

-Bool

-KdRandRGetInfo (ScreenPtr pScreen,

-		int randr,

-		Bool (*supported) (ScreenPtr pScreen,

-				   const KdMonitorTiming *));

-

-const KdMonitorTiming *

-KdRandRGetTiming (ScreenPtr	    pScreen,

-		  Bool		    (*supported) (ScreenPtr pScreen,

-						  const KdMonitorTiming *),

-		  int		    rate,

-		  RRScreenSizePtr   pSize);

-#endif

-

-/* kshadow.c */

-Bool

-KdShadowFbAlloc (KdScreenInfo *screen, Bool rotate);

-

-void

-KdShadowFbFree (KdScreenInfo *screen);

-

-Bool

-KdShadowSet (ScreenPtr pScreen, int randr, ShadowUpdateProc update, ShadowWindowProc window);

-

-void

-KdShadowUnset (ScreenPtr pScreen);

-

-/* function prototypes to be implemented by the drivers */

-void

-InitCard (char *name);

-

-#endif /* _KDRIVE_H_ */

+/*
+ * Copyright © 1999 Keith Packard
+ *
+ * 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 Keith Packard not be used in
+ * advertising or publicity pertaining to distribution of the software without
+ * specific, written prior permission.  Keith Packard makes no
+ * representations about the suitability of this software for any purpose.  It
+ * is provided "as is" without express or implied warranty.
+ *
+ * KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
+ * EVENT SHALL KEITH PACKARD 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.
+ */
+
+#ifndef _KDRIVE_H_
+#define _KDRIVE_H_
+
+#include <stdio.h>
+#include <string.h>
+#include <X11/X.h>
+#include <X11/Xproto.h>
+#include <X11/Xos.h>
+#include "scrnintstr.h"
+#include "pixmapstr.h"
+#include "windowstr.h"
+#include "servermd.h"
+#include "mibstore.h"
+#include "colormapst.h"
+#include "gcstruct.h"
+#include "input.h"
+#include "mipointer.h"
+#include "mi.h"
+#include "dix.h"
+#include "fb.h"
+#include "fboverlay.h"
+#include "shadow.h"
+#include "randrstr.h"
+#include "globals.h"
+
+#include "xkbstr.h"
+
+#define KD_DPMS_NORMAL	    0
+#define KD_DPMS_STANDBY	    1
+#define KD_DPMS_SUSPEND	    2
+#define KD_DPMS_POWERDOWN   3
+#define KD_DPMS_MAX	    KD_DPMS_POWERDOWN
+
+typedef int Status;
+
+typedef struct _KdCardInfo {
+    struct _KdCardFuncs	    *cfuncs;
+    void		    *closure;
+    void		    *driver;
+    struct _KdScreenInfo    *screenList;
+    int			    selected;
+    struct _KdCardInfo	    *next;
+} KdCardInfo;
+
+extern KdCardInfo	*kdCardInfo;
+
+/*
+ * Configuration information per X screen
+ */
+typedef struct _KdFrameBuffer {
+    CARD8	*frameBuffer;
+    int		depth;
+    int		bitsPerPixel;
+    int		pixelStride;
+    int		byteStride;
+    Bool	shadow;
+    unsigned long   visuals;
+    Pixel       redMask, greenMask, blueMask;
+    void	*closure;
+} KdFrameBuffer;
+
+#define RR_Rotate_All	(RR_Rotate_0|RR_Rotate_90|RR_Rotate_180|RR_Rotate_270)
+#define RR_Reflect_All	(RR_Reflect_X|RR_Reflect_Y)
+
+typedef struct _KdScreenInfo {
+    struct _KdScreenInfo    *next;
+    KdCardInfo	*card;
+    ScreenPtr	pScreen;
+    void	*driver;
+    Rotation	randr;	/* rotation and reflection */
+    int		width;
+    int		height;
+    int		rate;
+    int		width_mm;
+    int		height_mm;
+    int		subpixel_order;
+    Bool        dumb;
+    Bool        softCursor;
+    int		mynum;
+    DDXPointRec	origin;
+    KdFrameBuffer   fb;
+} KdScreenInfo;
+
+typedef struct _KdCardFuncs {
+    Bool	(*cardinit) (KdCardInfo *); /* detect and map device */
+    Bool	(*scrinit) (KdScreenInfo *);/* initialize screen information */
+    Bool	(*initScreen) (ScreenPtr);  /* initialize ScreenRec */
+    Bool	(*finishInitScreen) (ScreenPtr pScreen);
+    Bool	(*createRes) (ScreenPtr);   /* create screen resources */
+    void	(*preserve) (KdCardInfo *); /* save graphics card state */
+    Bool        (*enable) (ScreenPtr);      /* set up for rendering */
+    Bool	(*dpms) (ScreenPtr, int);   /* set DPMS screen saver */
+    void        (*disable) (ScreenPtr);     /* turn off rendering */
+    void	(*restore) (KdCardInfo *);  /* restore graphics card state */
+    void	(*scrfini) (KdScreenInfo *);/* close down screen */
+    void        (*cardfini) (KdCardInfo *); /* close down */
+
+    Bool        (*initCursor) (ScreenPtr);      /* detect and map cursor */
+    void        (*enableCursor) (ScreenPtr);    /* enable cursor */
+    void        (*disableCursor) (ScreenPtr);   /* disable cursor */
+    void        (*finiCursor) (ScreenPtr);      /* close down */
+    void        (*recolorCursor) (ScreenPtr, int, xColorItem *);
+
+    Bool        (*initAccel) (ScreenPtr);
+    void        (*enableAccel) (ScreenPtr);
+    void        (*disableAccel) (ScreenPtr);
+    void        (*finiAccel) (ScreenPtr);
+
+    void        (*getColors) (ScreenPtr, int, xColorItem *);
+    void        (*putColors) (ScreenPtr, int, xColorItem *);
+
+} KdCardFuncs;
+
+#define KD_MAX_PSEUDO_DEPTH 8
+#define KD_MAX_PSEUDO_SIZE	    (1 << KD_MAX_PSEUDO_DEPTH)
+
+typedef struct {
+    KdScreenInfo    *screen;
+    KdCardInfo	    *card;
+
+    Bool	    enabled;
+    Bool	    closed;
+    int		    bytesPerPixel;
+
+    int		    dpmsState;
+
+    ColormapPtr     pInstalledmap;                    /* current colormap */
+    xColorItem      systemPalette[KD_MAX_PSEUDO_SIZE];/* saved windows colors */
+
+    CreateScreenResourcesProcPtr    CreateScreenResources;
+    CloseScreenProcPtr  CloseScreen;
+} KdPrivScreenRec, *KdPrivScreenPtr;
+
+typedef enum _kdPointerState {
+    start,
+    button_1_pend,
+    button_1_down,
+    button_2_down,
+    button_3_pend,
+    button_3_down,
+    synth_2_down_13,
+    synth_2_down_3,
+    synth_2_down_1,
+    num_input_states
+} KdPointerState;
+
+#define KD_MAX_BUTTON  32
+
+#define KD_KEYBOARD 1
+#define KD_MOUSE 2
+#define KD_TOUCHSCREEN 3
+
+typedef struct _KdPointerInfo KdPointerInfo;
+
+typedef struct _KdPointerDriver {
+    char                    *name;
+    Status                  (*Init)    (KdPointerInfo *);
+    Status                  (*Enable)  (KdPointerInfo *);
+    void                    (*Disable) (KdPointerInfo *);
+    void                    (*Fini)    (KdPointerInfo *);
+    struct _KdPointerDriver *next;
+} KdPointerDriver;
+
+struct _KdPointerInfo {
+    DeviceIntPtr          dixdev;
+    char                  *name;
+    char                  *path;
+    char                  *protocol;
+    InputOption           *options;
+    int                   inputClass;
+
+    CARD8                 map[KD_MAX_BUTTON + 1];
+    int                   nButtons;
+    int                   nAxes;
+
+    Bool                  emulateMiddleButton;
+    unsigned long         emulationTimeout;
+    int                   emulationDx, emulationDy;
+
+    Bool                  timeoutPending;
+    KdPointerState        mouseState;
+    Bool                  eventHeld;
+    struct {
+        int type;
+        int x;
+        int y;
+        int z;
+        int flags;
+        int absrel;
+    } heldEvent;
+    unsigned char         buttonState;
+    Bool                  transformCoordinates;
+    int                   pressureThreshold;
+
+    KdPointerDriver       *driver;
+    void                  *driverPrivate;
+
+    struct _KdPointerInfo *next;
+};
+
+extern int KdCurScreen;
+
+void KdAddPointerDriver (KdPointerDriver *driver);
+void KdRemovePointerDriver (KdPointerDriver *driver);
+KdPointerInfo *KdNewPointer (void);
+void KdFreePointer (KdPointerInfo *);
+int KdAddPointer (KdPointerInfo *ki);
+int KdAddConfigPointer (char *pointer);
+void KdRemovePointer (KdPointerInfo *ki);
+
+
+#define KD_KEY_COUNT 248
+#define KD_MIN_KEYCODE  8
+#define KD_MAX_KEYCODE  255
+#define KD_MAX_WIDTH    4
+#define KD_MAX_LENGTH   (KD_MAX_KEYCODE - KD_MIN_KEYCODE + 1)
+
+typedef struct {
+    KeySym modsym;
+    int    modbit;
+} KdKeySymModsRec;
+
+typedef struct _KdKeyboardInfo KdKeyboardInfo;
+
+typedef struct _KdKeyboardDriver {
+    char                  *name;
+    Bool                  (*Init)    (KdKeyboardInfo *);
+    Bool                  (*Enable)  (KdKeyboardInfo *);
+    void                  (*Leds)    (KdKeyboardInfo *, int);
+    void                  (*Bell)    (KdKeyboardInfo *, int, int, int);
+    void                  (*Disable) (KdKeyboardInfo *);
+    void                  (*Fini)    (KdKeyboardInfo *);
+    struct _KdKeyboardDriver *next;
+} KdKeyboardDriver;
+
+struct _KdKeyboardInfo {
+    struct _KdKeyboardInfo *next;
+    DeviceIntPtr        dixdev;
+    void                *closure;
+    char                *name;
+    char                *path;
+    int                 inputClass;
+    char                *xkbRules;
+    char                *xkbModel;
+    char                *xkbLayout;
+    char                *xkbVariant;
+    char                *xkbOptions;
+    int                 LockLed;
+
+    int                 minScanCode;
+    int                 maxScanCode;
+
+    int                 leds;
+    int                 bellPitch;
+    int                 bellDuration;
+    InputOption         *options;
+
+    KdKeyboardDriver    *driver;
+    void                *driverPrivate;
+};
+
+void KdAddKeyboardDriver (KdKeyboardDriver *driver);
+void KdRemoveKeyboardDriver (KdKeyboardDriver *driver);
+KdKeyboardInfo *KdNewKeyboard (void);
+void KdFreeKeyboard (KdKeyboardInfo *ki);
+int KdAddConfigKeyboard (char *pointer);
+int KdAddKeyboard (KdKeyboardInfo *ki);
+void KdRemoveKeyboard (KdKeyboardInfo *ki);
+
+typedef struct _KdOsFuncs {
+    int		    (*Init) (void);
+    void	    (*Enable) (void);
+    Bool	    (*SpecialKey) (KeySym);
+    void	    (*Disable) (void);
+    void	    (*Fini) (void);
+    void	    (*pollEvents) (void);
+    void            (*Bell) (int, int, int);
+} KdOsFuncs;
+
+typedef enum _KdSyncPolarity {
+    KdSyncNegative, KdSyncPositive
+} KdSyncPolarity;
+
+typedef struct _KdMonitorTiming {
+    /* label */
+    int		    horizontal;
+    int		    vertical;
+    int		    rate;
+    /* pixel clock */
+    int		    clock;  /* in KHz */
+    /* horizontal timing */
+    int		    hfp;    /* front porch */
+    int		    hbp;    /* back porch */
+    int		    hblank; /* blanking */
+    KdSyncPolarity  hpol;   /* polarity */
+    /* vertical timing */
+    int		    vfp;    /* front porch */
+    int		    vbp;    /* back porch */
+    int		    vblank; /* blanking */
+    KdSyncPolarity  vpol;   /* polarity */
+} KdMonitorTiming;
+
+extern const KdMonitorTiming	kdMonitorTimings[];
+extern const int		kdNumMonitorTimings;
+
+typedef struct _KdPointerMatrix {
+    int	    matrix[2][3];
+} KdPointerMatrix;
+
+/*
+ * This is the only completely portable way to
+ * compute this info.
+ */
+
+#ifndef BitsPerPixel
+#define BitsPerPixel(d) (\
+    PixmapWidthPaddingInfo[d].notPower2 ? \
+    (PixmapWidthPaddingInfo[d].bytesPerPixel * 8) : \
+    ((1 << PixmapWidthPaddingInfo[d].padBytesLog2) * 8 / \
+    (PixmapWidthPaddingInfo[d].padRoundUp+1)))
+#endif
+
+extern DevPrivateKeyRec	kdScreenPrivateKeyRec;
+#define kdScreenPrivateKey (&kdScreenPrivateKeyRec)
+
+extern unsigned long	kdGeneration;
+extern Bool		kdEnabled;
+extern Bool		kdSwitchPending;
+extern Bool		kdEmulateMiddleButton;
+extern Bool		kdDisableZaphod;
+extern Bool		kdAllowZap;
+extern int		kdVirtualTerminal;
+extern char		*kdSwitchCmd;
+extern KdOsFuncs	*kdOsFuncs;
+
+#define KdGetScreenPriv(pScreen) ((KdPrivScreenPtr) \
+    dixLookupPrivate(&(pScreen)->devPrivates, kdScreenPrivateKey))
+#define KdSetScreenPriv(pScreen,v) \
+    dixSetPrivate(&(pScreen)->devPrivates, kdScreenPrivateKey, v)
+#define KdScreenPriv(pScreen) KdPrivScreenPtr pScreenPriv = KdGetScreenPriv(pScreen)
+
+/* kcmap.c */
+void
+KdSetColormap (ScreenPtr pScreen);
+
+void
+KdEnableColormap (ScreenPtr pScreen);
+
+void
+KdDisableColormap (ScreenPtr pScreen);
+
+void
+KdInstallColormap (ColormapPtr pCmap);
+
+void
+KdUninstallColormap (ColormapPtr pCmap);
+
+int
+KdListInstalledColormaps (ScreenPtr pScreen, Colormap *pCmaps);
+
+void
+KdStoreColors (ColormapPtr pCmap, int ndef, xColorItem *pdefs);
+
+/* kdrive.c */
+extern miPointerScreenFuncRec kdPointerScreenFuncs;
+
+void
+KdDisableScreen (ScreenPtr pScreen);
+
+void
+KdDisableScreens (void);
+
+Bool
+KdEnableScreen (ScreenPtr pScreen);
+
+void
+KdEnableScreens (void);
+
+void
+KdSuspend (void);
+
+void
+KdResume (void);
+
+void
+KdProcessSwitch (void);
+
+Rotation
+KdAddRotation (Rotation a, Rotation b);
+
+Rotation
+KdSubRotation (Rotation a, Rotation b);
+
+void
+KdParseScreen (KdScreenInfo *screen,
+	       char	    *arg);
+
+KdPointerInfo *
+KdParsePointer (char *arg);
+
+KdKeyboardInfo *
+KdParseKeyboard (char *arg);
+
+char *
+KdParseFindNext (char *cur, char *delim, char *save, char *last);
+
+void
+KdParseRgba (char *rgba);
+
+void
+KdUseMsg (void);
+
+int
+KdProcessArgument (int argc, char **argv, int i);
+
+void
+KdOsInit (KdOsFuncs *pOsFuncs);
+
+void
+KdOsAddInputDrivers (void);
+
+Bool
+KdAllocatePrivates (ScreenPtr pScreen);
+
+Bool
+KdCreateScreenResources (ScreenPtr pScreen);
+
+Bool
+KdCloseScreen (int index, ScreenPtr pScreen);
+
+Bool
+KdSaveScreen (ScreenPtr pScreen, int on);
+
+Bool
+KdScreenInit(int index, ScreenPtr pScreen, int argc, char **argv);
+
+void
+KdInitScreen (ScreenInfo    *pScreenInfo,
+	      KdScreenInfo  *screen,
+	      int	    argc,
+	      char	    **argv);
+
+void
+KdInitCard (ScreenInfo	    *pScreenInfo,
+	    KdCardInfo	    *card,
+	    int		    argc,
+	    char	    **argv);
+
+void
+KdInitOutput (ScreenInfo    *pScreenInfo,
+	      int	    argc,
+	      char	    **argv);
+
+void
+KdSetSubpixelOrder (ScreenPtr pScreen, Rotation randr);
+
+void
+KdBacktrace (int signum);
+
+/* kinfo.c */
+KdCardInfo *
+KdCardInfoAdd (KdCardFuncs  *funcs,
+	       void	    *closure);
+
+KdCardInfo *
+KdCardInfoLast (void);
+
+void
+KdCardInfoDispose (KdCardInfo *ci);
+
+KdScreenInfo *
+KdScreenInfoAdd (KdCardInfo *ci);
+
+void
+KdScreenInfoDispose (KdScreenInfo *si);
+
+
+/* kinput.c */
+void
+KdInitInput(void);
+void
+KdCloseInput(void);
+
+void
+KdAddPointerDriver(KdPointerDriver *);
+
+void
+KdAddKeyboardDriver(KdKeyboardDriver *);
+
+Bool
+KdRegisterFd (int fd, void (*read) (int fd, void *closure), void *closure);
+
+void
+KdUnregisterFds (void *closure, Bool do_close);
+
+void
+KdUnregisterFd (void *closure, int fd, Bool do_close);
+
+void
+KdEnqueueKeyboardEvent(KdKeyboardInfo *ki, unsigned char scan_code,
+                    unsigned char is_up);
+
+#define KD_BUTTON_1	0x01
+#define KD_BUTTON_2	0x02
+#define KD_BUTTON_3	0x04
+#define KD_BUTTON_4	0x08
+#define KD_BUTTON_5	0x10
+#define KD_BUTTON_8	0x80
+#define KD_MOUSE_DELTA	0x80000000
+
+void
+KdEnqueuePointerEvent(KdPointerInfo *pi, unsigned long flags, int rx, int ry,
+                      int rz);
+
+void
+_KdEnqueuePointerEvent(KdPointerInfo *pi, int type, int x, int y, int z,
+                       int b, int absrel, Bool force);
+
+void
+KdReleaseAllKeys (void);
+
+void
+KdSetLed (KdKeyboardInfo *ki, int led, Bool on);
+
+void
+KdSetPointerMatrix (KdPointerMatrix *pointer);
+
+void
+KdComputePointerMatrix (KdPointerMatrix *pointer, Rotation randr, int width, int height);
+
+void
+KdScreenToPointerCoords (int *x, int *y);
+
+void
+KdBlockHandler (int		screen,
+		pointer		blockData,
+		pointer		timeout,
+		pointer		readmask);
+
+void
+KdWakeupHandler (int		screen,
+		 pointer    	data,
+		 unsigned long	result,
+		 pointer	readmask);
+
+void
+KdDisableInput (void);
+
+void
+KdEnableInput (void);
+
+void
+ProcessInputEvents (void);
+
+void
+KdRingBell (KdKeyboardInfo      *ki,
+            int                 volume,
+            int                 pitch,
+            int                 duration);
+
+/* kmode.c */
+const KdMonitorTiming *
+KdFindMode (KdScreenInfo    *screen,
+	    Bool	    (*supported) (KdScreenInfo *,
+					  const KdMonitorTiming *));
+
+Bool
+KdTuneMode (KdScreenInfo    *screen,
+	    Bool	    (*usable) (KdScreenInfo *),
+	    Bool	    (*supported) (KdScreenInfo *,
+					  const KdMonitorTiming *));
+
+#ifdef RANDR
+Bool
+KdRandRGetInfo (ScreenPtr pScreen,
+		int randr,
+		Bool (*supported) (ScreenPtr pScreen,
+				   const KdMonitorTiming *));
+
+const KdMonitorTiming *
+KdRandRGetTiming (ScreenPtr	    pScreen,
+		  Bool		    (*supported) (ScreenPtr pScreen,
+						  const KdMonitorTiming *),
+		  int		    rate,
+		  RRScreenSizePtr   pSize);
+#endif
+
+/* kshadow.c */
+Bool
+KdShadowFbAlloc (KdScreenInfo *screen, Bool rotate);
+
+void
+KdShadowFbFree (KdScreenInfo *screen);
+
+Bool
+KdShadowSet (ScreenPtr pScreen, int randr, ShadowUpdateProc update, ShadowWindowProc window);
+
+void
+KdShadowUnset (ScreenPtr pScreen);
+
+/* function prototypes to be implemented by the drivers */
+void
+InitCard (char *name);
+
+#endif /* _KDRIVE_H_ */
diff --git a/xorg-server/hw/kdrive/src/kinput.c b/xorg-server/hw/kdrive/src/kinput.c
index 3358357f4..3d87996be 100644
--- a/xorg-server/hw/kdrive/src/kinput.c
+++ b/xorg-server/hw/kdrive/src/kinput.c
@@ -1,2345 +1,2345 @@
-/*

- * Copyright © 1999 Keith Packard

- * Copyright © 2006 Nokia Corporation

- *

- * 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 the authors not be used in

- * advertising or publicity pertaining to distribution of the software without

- * specific, written prior permission.  The authors make no

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

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

- *

- * THE AUTHORS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,

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

- * EVENT SHALL THE AUTHORS 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_CONFIG_H

-#include <kdrive-config.h>

-#endif

-#include "kdrive.h"

-#include "inputstr.h"

-

-#define XK_PUBLISHING

-#include <X11/keysym.h>

-#if HAVE_X11_XF86KEYSYM_H

-#include <X11/XF86keysym.h>

-#endif

-#include <signal.h>

-#include <stdio.h>

-#ifdef sun

-#include <sys/file.h> /* needed for FNONBLOCK & FASYNC */

-#endif

-

-#include "xkbsrv.h"

-

-#include <X11/extensions/XI.h>

-#include <X11/extensions/XIproto.h>

-#include "XIstubs.h" /* even though we don't use stubs.  cute, no? */

-#include "exevents.h"

-#include "extinit.h"

-#include "exglobals.h"

-#include "eventstr.h"

-#include "xserver-properties.h"

-#include "inpututils.h"

-

-#define AtomFromName(x) MakeAtom(x, strlen(x), 1)

-

-struct KdConfigDevice {

-    char *line;

-    struct KdConfigDevice *next;

-};

-

-/* kdKeyboards and kdPointers hold all the real devices. */

-static KdKeyboardInfo *kdKeyboards         = NULL;

-static KdPointerInfo  *kdPointers          = NULL;

-static struct KdConfigDevice *kdConfigKeyboards   = NULL;

-static struct KdConfigDevice *kdConfigPointers    = NULL;

-

-static KdKeyboardDriver *kdKeyboardDrivers = NULL;

-static KdPointerDriver  *kdPointerDrivers  = NULL;

-

-static Bool		kdInputEnabled;

-static Bool		kdOffScreen;

-static unsigned long	kdOffScreenTime;

-static KdPointerMatrix	kdPointerMatrix = {

-   { { 1, 0, 0 },

-     { 0, 1, 0 } }

-};

-

-void KdResetInputMachine (void);

-

-#define KD_MAX_INPUT_FDS    8

-

-typedef struct _kdInputFd {

-    int	        fd;

-    void        (*read) (int fd, void *closure);

-    int	        (*enable) (int fd, void *closure);

-    void        (*disable) (int fd, void *closure);

-    void        *closure;

-} KdInputFd;

-

-static KdInputFd kdInputFds[KD_MAX_INPUT_FDS];

-static int	 kdNumInputFds;

-

-extern Bool      kdRawPointerCoordinates;

-

-static void

-KdSigio (int sig)

-{

-    int	i;

-

-    for (i = 0; i < kdNumInputFds; i++)

-	(*kdInputFds[i].read) (kdInputFds[i].fd, kdInputFds[i].closure);

-}

-

-static void

-KdBlockSigio (void)

-{

-#ifdef _MSC_VER

-    __asm int 3;

-#else

-    sigset_t	set;

-

-    sigemptyset (&set);

-    sigaddset (&set, SIGIO);

-    sigprocmask (SIG_BLOCK, &set, 0);

-#endif

-}

-

-static void

-KdUnblockSigio (void)

-{

-#ifdef _MSC_VER

-    __asm int 3;

-#else

-    sigset_t	set;

-

-    sigemptyset (&set);

-    sigaddset (&set, SIGIO);

-    sigprocmask (SIG_UNBLOCK, &set, 0);

-#endif

-}

-

-#ifdef DEBUG_SIGIO

-

-void

-KdAssertSigioBlocked (char *where)

-{

-    sigset_t	set, old;

-

-    sigemptyset (&set);

-    sigprocmask (SIG_BLOCK, &set, &old);

-    if (!sigismember (&old, SIGIO)) {

-	ErrorF ("SIGIO not blocked at %s\n", where);

-        KdBacktrace(0);

-    }

-}

-

-#else

-

-#define KdAssertSigioBlocked(s)

-

-#endif

-

-static int  kdnFds;

-

-#ifdef FNONBLOCK

-#define NOBLOCK FNONBLOCK

-#else

-#define NOBLOCK FNDELAY

-#endif

-

-void

-KdResetInputMachine (void)

-{

-    KdPointerInfo *pi;

-

-    for (pi = kdPointers; pi; pi = pi->next) {

-        pi->mouseState = start;

-        pi->eventHeld = FALSE;

-    }

-}

-

-static void

-KdNonBlockFd (int fd)

-{

-#ifdef _MSC_VER

-    __asm int 3;

-#else

-    int	flags;

-    flags = fcntl (fd, F_GETFL);

-    flags |= FASYNC|NOBLOCK;

-    fcntl (fd, F_SETFL, flags);

-#endif

-}

-

-static void

-KdAddFd (int fd)

-{

-#ifdef _MSC_VER

-    __asm int 3;

-#else

-    struct sigaction	act;

-    sigset_t		set;

-

-    kdnFds++;

-    fcntl (fd, F_SETOWN, getpid());

-    KdNonBlockFd (fd);

-    AddEnabledDevice (fd);

-    memset (&act, '\0', sizeof act);

-    act.sa_handler = KdSigio;

-    sigemptyset (&act.sa_mask);

-    sigaddset (&act.sa_mask, SIGIO);

-    sigaddset (&act.sa_mask, SIGALRM);

-    sigaddset (&act.sa_mask, SIGVTALRM);

-    sigaction (SIGIO, &act, 0);

-    sigemptyset (&set);

-    sigprocmask (SIG_SETMASK, &set, 0);

-#endif

-}

-

-static void

-KdRemoveFd (int fd)

-{

-#ifdef _MSC_VER

-    __asm int 3;

-#else

-    struct sigaction	act;

-    int			flags;

-

-    kdnFds--;

-    RemoveEnabledDevice (fd);

-    flags = fcntl (fd, F_GETFL);

-    flags &= ~(FASYNC|NOBLOCK);

-    fcntl (fd, F_SETFL, flags);

-    if (kdnFds == 0)

-    {

-	memset (&act, '\0', sizeof act);

-	act.sa_handler = SIG_IGN;

-	sigemptyset (&act.sa_mask);

-	sigaction (SIGIO, &act, 0);

-    }

-#endif

-}

-

-Bool

-KdRegisterFd (int fd, void (*read) (int fd, void *closure), void *closure)

-{

-    if (kdNumInputFds == KD_MAX_INPUT_FDS)

-	return FALSE;

-    kdInputFds[kdNumInputFds].fd = fd;

-    kdInputFds[kdNumInputFds].read = read;

-    kdInputFds[kdNumInputFds].enable = 0;

-    kdInputFds[kdNumInputFds].disable = 0;

-    kdInputFds[kdNumInputFds].closure = closure;

-    kdNumInputFds++;

-    if (kdInputEnabled)

-	KdAddFd (fd);

-    return TRUE;

-}

-

-void

-KdUnregisterFd (void *closure, int fd, Bool do_close)

-{

-    int	i, j;

-

-    for (i = 0; i < kdNumInputFds; i++) {

-	if (kdInputFds[i].closure == closure &&

-            (fd == -1 || kdInputFds[i].fd == fd)) {

-	    if (kdInputEnabled)

-		KdRemoveFd (kdInputFds[i].fd);

-	    if (do_close)

-		close (kdInputFds[i].fd);

-	    kdNumInputFds--;

-	    for (j = i; j < kdNumInputFds; j++)

-		kdInputFds[j] = kdInputFds[j+1];

-            break;

-	}

-    }

-}

-

-void

-KdUnregisterFds (void *closure, Bool do_close)

-{

-    KdUnregisterFd(closure, -1, do_close);

-}

-

-void

-KdDisableInput (void)

-{

-    KdKeyboardInfo *ki;

-    KdPointerInfo *pi;

-    int found = 0, i = 0;

-

-    KdBlockSigio();

-

-    for (ki = kdKeyboards; ki; ki = ki->next) {

-        if (ki->driver && ki->driver->Disable)

-            (*ki->driver->Disable) (ki);

-    }

-

-    for (pi = kdPointers; pi; pi = pi->next) {

-        if (pi->driver && pi->driver->Disable)

-            (*pi->driver->Disable) (pi);

-    }

-

-    if (kdNumInputFds) {

-        ErrorF("[KdDisableInput] Buggy drivers: still %d input fds left!",

-               kdNumInputFds);

-        i = 0;

-        while (i < kdNumInputFds) {

-            found = 0;

-            for (ki = kdKeyboards; ki; ki = ki->next) {

-                if (ki == kdInputFds[i].closure) {

-                    ErrorF("    fd %d belongs to keybd driver %s\n",

-                           kdInputFds[i].fd,

-                           ki->driver && ki->driver->name ?

-                             ki->driver->name : "(unnamed!)");

-                    found = 1;

-                    break;

-                }

-            }

-

-            if (found) {

-                i++;

-                continue;

-            }

-

-            for (pi = kdPointers; pi; pi = pi->next) {

-                if (pi == kdInputFds[i].closure) {

-                    ErrorF("    fd %d belongs to pointer driver %s\n",

-                           kdInputFds[i].fd,

-                           pi->driver && pi->driver->name ?

-                             pi->driver->name : "(unnamed!)");

-                    break;

-                }

-            }

-

-            if (found) {

-                i++;

-                continue;

-            }

-

-            ErrorF("    fd %d not claimed by any active device!\n",

-                   kdInputFds[i].fd);

-            KdUnregisterFd(kdInputFds[i].closure, kdInputFds[i].fd, TRUE);

-        }

-    }

-

-    kdInputEnabled = FALSE;

-}

-

-void

-KdEnableInput (void)

-{

-    InternalEvent ev;

-    KdKeyboardInfo *ki;

-    KdPointerInfo *pi;

-

-    kdInputEnabled = TRUE;

-

-    for (ki = kdKeyboards; ki; ki = ki->next) {

-        if (ki->driver && ki->driver->Enable)

-            (*ki->driver->Enable) (ki);

-    }

-

-    for (pi = kdPointers; pi; pi = pi->next) {

-        if (pi->driver && pi->driver->Enable)

-            (*pi->driver->Enable) (pi);

-    }

-

-    /* reset screen saver */

-    ev.any.time = GetTimeInMillis ();

-    NoticeEventTime (&ev);

-

-    KdUnblockSigio ();

-}

-

-static KdKeyboardDriver *

-KdFindKeyboardDriver (char *name)

-{

-    KdKeyboardDriver *ret;

-

-    /* ask a stupid question ... */

-    if (!name)

-        return NULL;

-

-    for (ret = kdKeyboardDrivers; ret; ret = ret->next) {

-        if (strcmp(ret->name, name) == 0)

-            return ret;

-    }

-

-    return NULL;

-}

-

-static KdPointerDriver *

-KdFindPointerDriver (char *name)

-{

-    KdPointerDriver *ret;

-

-    /* ask a stupid question ... */

-    if (!name)

-        return NULL;

-

-    for (ret = kdPointerDrivers; ret; ret = ret->next) {

-        if (strcmp(ret->name, name) == 0)

-            return ret;

-    }

-

-    return NULL;

-}

-

-static int

-KdPointerProc(DeviceIntPtr pDevice, int onoff)

-{

-    DevicePtr       pDev = (DevicePtr)pDevice;

-    KdPointerInfo   *pi;

-    Atom            xiclass;

-    Atom            *btn_labels;

-    Atom            *axes_labels;

-

-    if (!pDev)

-	return BadImplementation;

-

-    for (pi = kdPointers; pi; pi = pi->next) {

-        if (pi->dixdev && pi->dixdev->id == pDevice->id)

-            break;

-    }

-

-    if (!pi || !pi->dixdev || pi->dixdev->id != pDevice->id) {

-        ErrorF("[KdPointerProc] Failed to find pointer for device %d!\n",

-               pDevice->id);

-        return BadImplementation;

-    }

-

-    switch (onoff)

-    {

-    case DEVICE_INIT:

-#ifdef DEBUG

-        ErrorF("initialising pointer %s ...\n", pi->name);

-#endif

-        if (!pi->driver) {

-            if (!pi->driverPrivate) {

-                ErrorF("no driver specified for %s\n", pi->name);

-                return BadImplementation;

-            }

-

-            pi->driver = KdFindPointerDriver(pi->driverPrivate);

-            if (!pi->driver) {

-                ErrorF("Couldn't find pointer driver %s\n",

-                       pi->driverPrivate ? (char *) pi->driverPrivate :

-                       "(unnamed)");

-                return !Success;

-            }

-            free(pi->driverPrivate);

-            pi->driverPrivate = NULL;

-        }

-

-        if (!pi->driver->Init) {

-            ErrorF("no init function\n");

-            return BadImplementation;

-        }

-

-        if ((*pi->driver->Init) (pi) != Success) {

-            return !Success;

-        }

-

-	btn_labels = calloc(pi->nButtons, sizeof(Atom));

-	if (!btn_labels)

-	    return BadAlloc;

-	axes_labels = calloc(pi->nAxes, sizeof(Atom));

-	if (!axes_labels) {

-	    free(btn_labels);

-	    return BadAlloc;

-	}

-

-	switch(pi->nAxes)

-	{

-	    default:

-	    case 7:

-		btn_labels[6] = XIGetKnownProperty(BTN_LABEL_PROP_BTN_HWHEEL_RIGHT);

-	    case 6:

-		btn_labels[5] = XIGetKnownProperty(BTN_LABEL_PROP_BTN_HWHEEL_LEFT);

-	    case 5:

-		btn_labels[4] = XIGetKnownProperty(BTN_LABEL_PROP_BTN_WHEEL_DOWN);

-	    case 4:

-		btn_labels[3] = XIGetKnownProperty(BTN_LABEL_PROP_BTN_WHEEL_UP);

-	    case 3:

-		btn_labels[2] = XIGetKnownProperty(BTN_LABEL_PROP_BTN_RIGHT);

-	    case 2:

-		btn_labels[1] = XIGetKnownProperty(BTN_LABEL_PROP_BTN_MIDDLE);

-	    case 1:

-		btn_labels[0] = XIGetKnownProperty(BTN_LABEL_PROP_BTN_LEFT);

-	    case 0:

-		break;

-	}

-

-	if (pi->nAxes >= 2) {

-	    axes_labels[0] = XIGetKnownProperty(AXIS_LABEL_PROP_REL_X);

-	    axes_labels[1] = XIGetKnownProperty(AXIS_LABEL_PROP_REL_Y);

-	}

-

-	InitPointerDeviceStruct(pDev, pi->map, pi->nButtons, btn_labels,

-	    (PtrCtrlProcPtr)NoopDDA,

-	    GetMotionHistorySize(), pi->nAxes, axes_labels);

-

-        free(btn_labels);

-        free(axes_labels);

-

-        if (pi->inputClass == KD_TOUCHSCREEN) {

-            xiclass = AtomFromName(XI_TOUCHSCREEN);

-        }

-        else {

-            xiclass = AtomFromName(XI_MOUSE);

-        }

-

-        AssignTypeAndName(pi->dixdev, xiclass,

-                          pi->name ? pi->name : "Generic KDrive Pointer");

-

-	return Success;

-

-    case DEVICE_ON:

-        if (pDev->on == TRUE)

-            return Success;

-

-        if (!pi->driver->Enable) {

-            ErrorF("no enable function\n");

-            return BadImplementation;

-        }

-

-        if ((*pi->driver->Enable) (pi) == Success) {

-            pDev->on = TRUE;

-            return Success;

-        }

-        else {

-            return BadImplementation;

-        }

-

-	return Success;

-

-    case DEVICE_OFF:

-        if (pDev->on == FALSE) {

-            return Success;

-        }

-

-        if (!pi->driver->Disable) {

-            return BadImplementation;

-        }

-        else {

-            (*pi->driver->Disable) (pi);

-            pDev->on = FALSE;

-            return Success;

-        }

-

-        return Success;

-

-    case DEVICE_CLOSE:

-	if (pDev->on) {

-            if (!pi->driver->Disable) {

-                return BadImplementation;

-            }

-            (*pi->driver->Disable) (pi);

-            pDev->on = FALSE;

-        }

-

-        if (!pi->driver->Fini)

-            return BadImplementation;

-

-        (*pi->driver->Fini) (pi);

-

-        KdRemovePointer(pi);

-

-        return Success;

-    }

-

-    /* NOTREACHED */

-    return BadImplementation;

-}

-

-#ifndef _MSC_VER

-Bool

-LegalModifier(unsigned int key, DeviceIntPtr pDev)

-{

-    return TRUE;

-}

-#endif

-

-static void

-KdBell (int volume, DeviceIntPtr pDev, pointer arg, int something)

-{

-    KeybdCtrl *ctrl = arg;

-    KdKeyboardInfo *ki = NULL;

-

-    for (ki = kdKeyboards; ki; ki = ki->next) {

-        if (ki->dixdev && ki->dixdev->id == pDev->id)

-            break;

-    }

-

-    if (!ki || !ki->dixdev || ki->dixdev->id != pDev->id || !ki->driver)

-        return;

-

-    KdRingBell(ki, volume, ctrl->bell_pitch, ctrl->bell_duration);

-}

-

-#ifndef _MSC_VER

-void

-DDXRingBell(int volume, int pitch, int duration)

-{

-    KdKeyboardInfo *ki = NULL;

-

-    if (kdOsFuncs->Bell) {

-        (*kdOsFuncs->Bell)(volume, pitch, duration);

-    }

-    else {

-        for (ki = kdKeyboards; ki; ki = ki->next) {

-            if (ki->dixdev->coreEvents)

-                KdRingBell(ki, volume, pitch, duration);

-        }

-    }

-}

-#endif

-void

-KdRingBell(KdKeyboardInfo *ki, int volume, int pitch, int duration)

-{

-    if (!ki || !ki->driver || !ki->driver->Bell)

-        return;

-

-    if (kdInputEnabled)

-        (*ki->driver->Bell) (ki, volume, pitch, duration);

-}

-

-

-static void

-KdSetLeds (KdKeyboardInfo *ki, int leds)

-{

-    if (!ki || !ki->driver)

-        return;

-

-    if (kdInputEnabled) {

-        if (ki->driver->Leds)

-            (*ki->driver->Leds) (ki, leds);

-    }

-}

-

-void

-KdSetLed (KdKeyboardInfo *ki, int led, Bool on)

-{

-    if (!ki || !ki->dixdev || !ki->dixdev->kbdfeed)

-        return;

-

-    NoteLedState (ki->dixdev, led, on);

-    KdSetLeds (ki, ki->dixdev->kbdfeed->ctrl.leds);

-}

-

-void

-KdSetPointerMatrix (KdPointerMatrix *matrix)

-{

-    kdPointerMatrix = *matrix;

-}

-

-void

-KdComputePointerMatrix (KdPointerMatrix *m, Rotation randr, int width,

-                        int height)

-{

-    int		    x_dir = 1, y_dir = 1;

-    int		    i, j;

-    int		    size[2];

-

-    size[0] = width; size[1] = height;

-    if (randr & RR_Reflect_X)

-	x_dir = -1;

-    if (randr & RR_Reflect_Y)

-	y_dir = -1;

-    switch (randr & (RR_Rotate_All)) {

-    case RR_Rotate_0:

-	m->matrix[0][0] = x_dir; m->matrix[0][1] = 0;

-	m->matrix[1][0] = 0; m->matrix[1][1] = y_dir;

-	break;

-    case RR_Rotate_90:

-	m->matrix[0][0] = 0; m->matrix[0][1] = -x_dir;

-	m->matrix[1][0] = y_dir; m->matrix[1][1] = 0;

-	break;

-    case RR_Rotate_180:

-	m->matrix[0][0] = -x_dir; m->matrix[0][1] = 0;

-	m->matrix[1][0] = 0; m->matrix[1][1] = -y_dir;

-	break;

-    case RR_Rotate_270:

-	m->matrix[0][0] = 0; m->matrix[0][1] = x_dir;

-	m->matrix[1][0] = -y_dir; m->matrix[1][1] = 0;

-	break;

-    }

-    for (i = 0; i < 2; i++)

-    {

-	m->matrix[i][2] = 0;

-	for (j = 0 ; j < 2; j++)

-	    if (m->matrix[i][j] < 0)

-		m->matrix[i][2] = size[j] - 1;

-    }

-}

-

-void

-KdScreenToPointerCoords (int *x, int *y)

-{

-    int	(*m)[3] = kdPointerMatrix.matrix;

-    int div = m[0][1] * m[1][0] - m[1][1] * m[0][0];

-    int sx = *x;

-    int sy = *y;

-

-    *x = (m[0][1] * sy - m[0][1] * m[1][2] + m[1][1] * m[0][2] - m[1][1] * sx) / div;

-    *y = (m[1][0] * sx + m[0][0] * m[1][2] - m[1][0] * m[0][2] - m[0][0] * sy) / div;

-}

-

-static void

-KdKbdCtrl (DeviceIntPtr pDevice, KeybdCtrl *ctrl)

-{

-    KdKeyboardInfo *ki;

-

-    for (ki = kdKeyboards; ki; ki = ki->next) {

-        if (ki->dixdev && ki->dixdev->id == pDevice->id)

-            break;

-    }

-

-    if (!ki || !ki->dixdev || ki->dixdev->id != pDevice->id || !ki->driver)

-        return;

-

-    KdSetLeds(ki, ctrl->leds);

-    ki->bellPitch = ctrl->bell_pitch;

-    ki->bellDuration = ctrl->bell_duration;

-}

-

-extern KeybdCtrl defaultKeyboardControl;

-

-static int

-KdKeyboardProc(DeviceIntPtr pDevice, int onoff)

-{

-    Bool        ret;

-    DevicePtr   pDev = (DevicePtr)pDevice;

-    KdKeyboardInfo *ki;

-    Atom xiclass;

-    XkbRMLVOSet rmlvo;

-

-    if (!pDev)

-	return BadImplementation;

-

-    for (ki = kdKeyboards; ki; ki = ki->next) {

-        if (ki->dixdev && ki->dixdev->id == pDevice->id)

-            break;

-    }

-

-    if (!ki || !ki->dixdev || ki->dixdev->id != pDevice->id) {

-        return BadImplementation;

-    }

-

-    switch (onoff)

-    {

-    case DEVICE_INIT:

-#ifdef DEBUG

-        ErrorF("initialising keyboard %s\n", ki->name);

-#endif

-        if (!ki->driver) {

-            if (!ki->driverPrivate) {

-                ErrorF("no driver specified!\n");

-                return BadImplementation;

-            }

-

-            ki->driver = KdFindKeyboardDriver(ki->driverPrivate);

-            if (!ki->driver) {

-                ErrorF("Couldn't find keyboard driver %s\n",

-                       ki->driverPrivate ? (char *) ki->driverPrivate :

-                       "(unnamed)");

-                return !Success;

-            }

-            free(ki->driverPrivate);

-            ki->driverPrivate = NULL;

-        }

-

-        if (!ki->driver->Init) {

-            ErrorF("Keyboard %s: no init function\n", ki->name);

-            return BadImplementation;

-        }

-

-        if ((*ki->driver->Init) (ki) != Success) {

-            return !Success;

-        }

-

-        memset(&rmlvo, 0, sizeof(rmlvo));

-        rmlvo.rules = ki->xkbRules;

-        rmlvo.model = ki->xkbModel;

-        rmlvo.layout = ki->xkbLayout;

-        rmlvo.variant = ki->xkbVariant;

-        rmlvo.options = ki->xkbOptions;

-        ret = InitKeyboardDeviceStruct (pDevice, &rmlvo, KdBell, KdKbdCtrl);

-	if (!ret) {

-            ErrorF("Couldn't initialise keyboard %s\n", ki->name);

-	    return BadImplementation;

-        }

-

-        xiclass = AtomFromName(XI_KEYBOARD);

-        AssignTypeAndName(pDevice, xiclass,

-                          ki->name ? ki->name : "Generic KDrive Keyboard");

-

-        KdResetInputMachine();

-

-        return Success;

-

-    case DEVICE_ON:

-        if (pDev->on == TRUE)

-            return Success;

-

-        if (!ki->driver->Enable)

-            return BadImplementation;

-

-        if ((*ki->driver->Enable) (ki) != Success) {

-            return BadMatch;

-        }

-

-        pDev->on = TRUE;

-        return Success;

-

-    case DEVICE_OFF:

-        if (pDev->on == FALSE)

-            return Success;

-

-        if (!ki->driver->Disable)

-            return BadImplementation;

-

-        (*ki->driver->Disable) (ki);

-        pDev->on = FALSE;

-

-        return Success;

-

-        break;

-

-    case DEVICE_CLOSE:

-	if (pDev->on) {

-            if (!ki->driver->Disable)

-                return BadImplementation;

-

-            (*ki->driver->Disable) (ki);

-            pDev->on = FALSE;

-	}

-

-        if (!ki->driver->Fini)

-            return BadImplementation;

-

-        (*ki->driver->Fini) (ki);

-

-        KdRemoveKeyboard(ki);

-

-        return Success;

-    }

-

-    /* NOTREACHED */

-    return BadImplementation;

-}

-

-void

-KdAddPointerDriver (KdPointerDriver *driver)

-{

-    KdPointerDriver **prev;

-

-    if (!driver)

-        return;

-

-    for (prev = &kdPointerDrivers; *prev; prev = &(*prev)->next) {

-        if (*prev == driver)

-            return;

-    }

-    *prev = driver;

-}

-

-void

-KdRemovePointerDriver (KdPointerDriver *driver)

-{

-    KdPointerDriver *tmp;

-

-    if (!driver)

-        return;

-

-    /* FIXME remove all pointers using this driver */

-    for (tmp = kdPointerDrivers; tmp; tmp = tmp->next) {

-        if (tmp->next == driver)

-            tmp->next = driver->next;

-    }

-    if (tmp == driver)

-        tmp = NULL;

-}

-

-void

-KdAddKeyboardDriver (KdKeyboardDriver *driver)

-{

-    KdKeyboardDriver **prev;

-

-    if (!driver)

-        return;

-

-    for (prev = &kdKeyboardDrivers; *prev; prev = &(*prev)->next) {

-        if (*prev == driver)

-            return;

-    }

-    *prev = driver;

-}

-

-void

-KdRemoveKeyboardDriver (KdKeyboardDriver *driver)

-{

-    KdKeyboardDriver *tmp;

-

-    if (!driver)

-        return;

-

-    /* FIXME remove all keyboards using this driver */

-    for (tmp = kdKeyboardDrivers; tmp; tmp = tmp->next) {

-        if (tmp->next == driver)

-            tmp->next = driver->next;

-    }

-    if (tmp == driver)

-        tmp = NULL;

-}

-

-KdKeyboardInfo *

-KdNewKeyboard (void)

-{

-    KdKeyboardInfo *ki = calloc(sizeof(KdKeyboardInfo), 1);

-    if (!ki)

-        return NULL;

-

-    ki->minScanCode = 0;

-    ki->maxScanCode = 0;

-    ki->leds = 0;

-    ki->bellPitch = 1000;

-    ki->bellDuration = 200;

-    ki->next = NULL;

-    ki->options = NULL;

-    ki->xkbRules = strdup(XKB_DFLT_RULES);

-    ki->xkbModel = strdup(XKB_DFLT_MODEL);

-    ki->xkbLayout = strdup(XKB_DFLT_LAYOUT);

-    ki->xkbVariant = strdup(XKB_DFLT_VARIANT);

-    ki->xkbOptions = strdup(XKB_DFLT_OPTIONS);

-

-    return ki;

-}

-

-int

-KdAddConfigKeyboard (char *keyboard)

-{

-    struct KdConfigDevice **prev, *new;

-

-    if (!keyboard)

-        return Success;

-

-    new = (struct KdConfigDevice *) calloc(sizeof(struct KdConfigDevice), 1);

-    if (!new)

-        return BadAlloc;

-

-    new->line = strdup(keyboard);

-    new->next = NULL;

-

-    for (prev = &kdConfigKeyboards; *prev; prev = &(*prev)->next);

-    *prev = new;

-

-    return Success;

-}

-

-int

-KdAddKeyboard (KdKeyboardInfo *ki)

-{

-    KdKeyboardInfo **prev;

-

-    if (!ki)

-        return !Success;

-

-    ki->dixdev = AddInputDevice(serverClient, KdKeyboardProc, TRUE);

-    if (!ki->dixdev) {

-        ErrorF("Couldn't register keyboard device %s\n",

-               ki->name ? ki->name : "(unnamed)");

-        return !Success;

-    }

-

-#ifdef DEBUG

-    ErrorF("added keyboard %s with dix id %d\n", ki->name, ki->dixdev->id);

-#endif

-

-    for (prev = &kdKeyboards; *prev; prev = &(*prev)->next);

-    *prev = ki;

-

-    return Success;

-}

-

-void

-KdRemoveKeyboard (KdKeyboardInfo *ki)

-{

-    KdKeyboardInfo **prev;

-

-    if (!ki)

-        return;

-

-    for (prev = &kdKeyboards; *prev; prev = &(*prev)->next) {

-        if (*prev == ki) {

-            *prev = ki->next;

-            break;

-        }

-    }

-

-    KdFreeKeyboard(ki);

-}

-

-int

-KdAddConfigPointer (char *pointer)

-{

-    struct KdConfigDevice **prev, *new;

-

-    if (!pointer)

-        return Success;

-

-    new = (struct KdConfigDevice *) calloc(sizeof(struct KdConfigDevice), 1);

-    if (!new)

-        return BadAlloc;

-

-    new->line = strdup(pointer);

-    new->next = NULL;

-

-    for (prev = &kdConfigPointers; *prev; prev = &(*prev)->next);

-    *prev = new;

-

-    return Success;

-}

-

-int

-KdAddPointer (KdPointerInfo *pi)

-{

-    KdPointerInfo **prev;

-

-    if (!pi)

-        return Success;

-

-    pi->mouseState = start;

-    pi->eventHeld = FALSE;

-

-    pi->dixdev = AddInputDevice(serverClient, KdPointerProc, TRUE);

-    if (!pi->dixdev) {

-        ErrorF("Couldn't add pointer device %s\n",

-               pi->name ? pi->name : "(unnamed)");

-        return BadDevice;

-    }

-

-    for (prev = &kdPointers; *prev; prev = &(*prev)->next);

-    *prev = pi;

-

-    return Success;

-}

-

-void

-KdRemovePointer (KdPointerInfo *pi)

-{

-    KdPointerInfo **prev;

-

-    if (!pi)

-        return;

-

-    for (prev = &kdPointers; *prev; prev = &(*prev)->next) {

-        if (*prev == pi) {

-            *prev = pi->next;

-            break;

-        }

-    }

-

-    KdFreePointer(pi);

-}

-

-/*

- * You can call your kdriver server with something like:

- * $ ./hw/kdrive/yourserver/X :1 -mouse evdev,,device=/dev/input/event4 -keybd

- * evdev,,device=/dev/input/event1,xkbmodel=abnt2,xkblayout=br

- */

-static Bool

-KdGetOptions (InputOption **options, char *string)

-{

-    InputOption     *newopt = NULL, **tmpo = NULL;

-    int             tam_key = 0;

-

-    newopt = calloc(1, sizeof (InputOption));

-    if (!newopt)

-        return FALSE;

-

-    for (tmpo = options; *tmpo; tmpo = &(*tmpo)->next)

-        ; /* Hello, I'm here */

-    *tmpo = newopt;

-

-    if (strchr(string, '='))

-    {

-        tam_key = (strchr(string, '=') - string);

-        newopt->key = (char *)malloc(tam_key);

-        strncpy(newopt->key, string, tam_key);

-        newopt->key[tam_key] = '\0';

-        newopt->value = strdup(strchr(string, '=') + 1);

-    }

-    else

-    {

-        newopt->key = strdup(string);

-        newopt->value = NULL;

-    }

-    newopt->next = NULL;

-

-    return TRUE;

-}

-

-static void

-KdParseKbdOptions (KdKeyboardInfo *ki)

-{

-    InputOption *option = NULL;

-

-    for (option = ki->options; option; option = option->next)

-    {

-        if (strcasecmp(option->key, "XkbRules") == 0)

-            ki->xkbRules = option->value;

-        else if (strcasecmp(option->key, "XkbModel") == 0)

-            ki->xkbModel = option->value;

-        else if (strcasecmp(option->key, "XkbLayout") == 0)

-            ki->xkbLayout = option->value;

-        else if (strcasecmp(option->key, "XkbVariant") == 0)

-            ki->xkbVariant = option->value;

-        else if (strcasecmp(option->key, "XkbOptions") == 0)

-            ki->xkbOptions = option->value;

-        else if (!strcasecmp (option->key, "device"))

-            ki->path = strdup(option->value);

-        else

-           ErrorF("Kbd option key (%s) of value (%s) not assigned!\n",

-                    option->key, option->value);

-    }

-}

-

-KdKeyboardInfo *

-KdParseKeyboard (char *arg)

-{

-    char            save[1024];

-    char            delim;

-    InputOption     *options = NULL;

-    KdKeyboardInfo     *ki = NULL;

-

-    ki = KdNewKeyboard();

-    if (!ki)

-        return NULL;

-

-    ki->name = strdup("Unknown KDrive Keyboard");

-    ki->path = NULL;

-    ki->driver = NULL;

-    ki->driverPrivate = NULL;

-    ki->next = NULL;

-

-    if (!arg)

-    {

-        ErrorF("keybd: no arg\n");

-        KdFreeKeyboard (ki);

-        return NULL;

-    }

-

-    if (strlen (arg) >= sizeof (save))

-    {

-        ErrorF("keybd: arg too long\n");

-        KdFreeKeyboard (ki);

-        return NULL;

-    }

-

-    arg = KdParseFindNext (arg, ",", save, &delim);

-    if (!save[0])

-    {

-        ErrorF("keybd: failed on save[0]\n");

-        KdFreeKeyboard (ki);

-        return NULL;

-    }

-

-    if (strcmp (save, "auto") == 0)

-        ki->driverPrivate = NULL;

-    else

-        ki->driverPrivate = strdup(save);

-

-    if (delim != ',')

-    {

-        return ki;

-    }

-

-    arg = KdParseFindNext (arg, ",", save, &delim);

-

-    while (delim == ',')

-    {

-        arg = KdParseFindNext (arg, ",", save, &delim);

-

-	if (!KdGetOptions(&options, save))

-	{

-	    KdFreeKeyboard(ki);

-	    return NULL;

-        }

-    }

-

-    if (options)

-    {

-        ki->options = options;

-        KdParseKbdOptions(ki);

-    }

-

-    return ki;

-}

-

-static void

-KdParsePointerOptions (KdPointerInfo *pi)

-{

-    InputOption *option = NULL;

-

-    for (option = pi->options; option; option = option->next)

-    {

-        if (!strcmp (option->key, "emulatemiddle"))

-            pi->emulateMiddleButton = TRUE;

-        else if (!strcmp (option->key, "noemulatemiddle"))

-            pi->emulateMiddleButton = FALSE;

-        else if (!strcmp (option->key, "transformcoord"))

-            pi->transformCoordinates = TRUE;

-        else if (!strcmp (option->key, "rawcoord"))

-            pi->transformCoordinates = FALSE;

-        else if (!strcasecmp (option->key, "device"))

-            pi->path = strdup(option->value);

-        else if (!strcasecmp (option->key, "protocol"))

-            pi->protocol = strdup(option->value);

-        else

-            ErrorF("Pointer option key (%s) of value (%s) not assigned!\n",

-                    option->key, option->value);

-    }

-}

-

-KdPointerInfo *

-KdParsePointer (char *arg)

-{

-    char            save[1024];

-    char            delim;

-    KdPointerInfo   *pi = NULL;

-    InputOption     *options = NULL;

-    int             i = 0;

-

-    pi = KdNewPointer();

-    if (!pi)

-        return NULL;

-    pi->emulateMiddleButton = kdEmulateMiddleButton;

-    pi->transformCoordinates = !kdRawPointerCoordinates;

-    pi->protocol = NULL;

-    pi->nButtons = 5; /* XXX should not be hardcoded */

-    pi->inputClass = KD_MOUSE;

-

-    if (!arg)

-    {

-        ErrorF("mouse: no arg\n");

-        KdFreePointer (pi);

-        return NULL;

-    }

-

-    if (strlen (arg) >= sizeof (save))

-    {

-        ErrorF("mouse: arg too long\n");

-        KdFreePointer (pi);

-        return NULL;

-    }

-    arg = KdParseFindNext (arg, ",", save, &delim);

-    if (!save[0])

-    {

-        ErrorF("failed on save[0]\n");

-        KdFreePointer (pi);

-        return NULL;

-    }

-

-    if (strcmp(save, "auto") == 0)

-        pi->driverPrivate = NULL;

-    else

-        pi->driverPrivate = strdup(save);

-

-    if (delim != ',')

-    {

-        return pi;

-    }

-

-    arg = KdParseFindNext (arg, ",", save, &delim);

-

-    while (delim == ',')

-    {

-        arg = KdParseFindNext (arg, ",", save, &delim);

-        if (save[0] == '{')

-        {

-            char *s = save + 1;

-             i = 0;

-             while (*s && *s != '}')

-             {

-                if ('1' <= *s && *s <= '0' + pi->nButtons)

-                    pi->map[i] = *s - '0';

-                else

-                    UseMsg ();

-                s++;

-             }

-        }

-        else

-        {

-            if (!KdGetOptions(&options, save))

-            {

-                KdFreePointer(pi);

-                return NULL;

-            }

-        }

-    }

-

-    if (options)

-    {

-        pi->options = options;

-        KdParsePointerOptions(pi);

-    }

-

-    return pi;

-}

-

-

-void

-KdInitInput (void)

-{

-    KdPointerInfo *pi;

-    KdKeyboardInfo *ki;

-    struct KdConfigDevice *dev;

-

-    kdInputEnabled = TRUE;

-

-    for (dev = kdConfigPointers; dev; dev = dev->next) {

-        pi = KdParsePointer(dev->line);

-        if (!pi)

-            ErrorF("Failed to parse pointer\n");

-        if (KdAddPointer(pi) != Success)

-            ErrorF("Failed to add pointer!\n");

-    }

-    for (dev = kdConfigKeyboards; dev; dev = dev->next) {

-        ki = KdParseKeyboard(dev->line);

-        if (!ki)

-            ErrorF("Failed to parse keyboard\n");

-        if (KdAddKeyboard(ki) != Success)

-            ErrorF("Failed to add keyboard!\n");

-    }

-

-    mieqInit();

-}

-

-void

-KdCloseInput (void)

-{

-    mieqFini();

-}

-

-/*

- * Middle button emulation state machine

- *

- *  Possible transitions:

- *	Button 1 press	    v1

- *	Button 1 release    ^1

- *	Button 2 press	    v2

- *	Button 2 release    ^2

- *	Button 3 press	    v3

- *	Button 3 release    ^3

- *	Button other press  vo

- *	Button other release ^o

- *	Mouse motion	    <>

- *	Keyboard event	    k

- *	timeout		    ...

- *	outside box	    <->

- *

- *  States:

- *	start

- *	button_1_pend

- *	button_1_down

- *	button_2_down

- *	button_3_pend

- *	button_3_down

- *	synthetic_2_down_13

- *	synthetic_2_down_3

- *	synthetic_2_down_1

- *

- *  Transition diagram

- *

- *  start

- *	v1  -> (hold) (settimeout) button_1_pend

- *	^1  -> (deliver) start

- *	v2  -> (deliver) button_2_down

- *	^2  -> (deliever) start

- *	v3  -> (hold) (settimeout) button_3_pend

- *	^3  -> (deliver) start

- *	vo  -> (deliver) start

- *	^o  -> (deliver) start

- *	<>  -> (deliver) start

- *	k   -> (deliver) start

- *

- *  button_1_pend	(button 1 is down, timeout pending)

- *	^1  -> (release) (deliver) start

- *	v2  -> (release) (deliver) button_1_down

- *	^2  -> (release) (deliver) button_1_down

- *	v3  -> (cleartimeout) (generate v2) synthetic_2_down_13

- *	^3  -> (release) (deliver) button_1_down

- *	vo  -> (release) (deliver) button_1_down

- *	^o  -> (release) (deliver) button_1_down

- *	<-> -> (release) (deliver) button_1_down

- *	<>  -> (deliver) button_1_pend

- *	k   -> (release) (deliver) button_1_down

- *	... -> (release) button_1_down

- *

- *  button_1_down	(button 1 is down)

- *	^1  -> (deliver) start

- *	v2  -> (deliver) button_1_down

- *	^2  -> (deliver) button_1_down

- *	v3  -> (deliver) button_1_down

- *	^3  -> (deliver) button_1_down

- *	vo  -> (deliver) button_1_down

- *	^o  -> (deliver) button_1_down

- *	<>  -> (deliver) button_1_down

- *	k   -> (deliver) button_1_down

- *

- *  button_2_down	(button 2 is down)

- *	v1  -> (deliver) button_2_down

- *	^1  -> (deliver) button_2_down

- *	^2  -> (deliver) start

- *	v3  -> (deliver) button_2_down

- *	^3  -> (deliver) button_2_down

- *	vo  -> (deliver) button_2_down

- *	^o  -> (deliver) button_2_down

- *	<>  -> (deliver) button_2_down

- *	k   -> (deliver) button_2_down

- *

- *  button_3_pend	(button 3 is down, timeout pending)

- *	v1  -> (generate v2) synthetic_2_down

- *	^1  -> (release) (deliver) button_3_down

- *	v2  -> (release) (deliver) button_3_down

- *	^2  -> (release) (deliver) button_3_down

- *	^3  -> (release) (deliver) start

- *	vo  -> (release) (deliver) button_3_down

- *	^o  -> (release) (deliver) button_3_down

- *	<-> -> (release) (deliver) button_3_down

- *	<>  -> (deliver) button_3_pend

- *	k   -> (release) (deliver) button_3_down

- *	... -> (release) button_3_down

- *

- *  button_3_down	(button 3 is down)

- *	v1  -> (deliver) button_3_down

- *	^1  -> (deliver) button_3_down

- *	v2  -> (deliver) button_3_down

- *	^2  -> (deliver) button_3_down

- *	^3  -> (deliver) start

- *	vo  -> (deliver) button_3_down

- *	^o  -> (deliver) button_3_down

- *	<>  -> (deliver) button_3_down

- *	k   -> (deliver) button_3_down

- *

- *  synthetic_2_down_13	(button 1 and 3 are down)

- *	^1  -> (generate ^2) synthetic_2_down_3

- *	v2  -> synthetic_2_down_13

- *	^2  -> synthetic_2_down_13

- *	^3  -> (generate ^2) synthetic_2_down_1

- *	vo  -> (deliver) synthetic_2_down_13

- *	^o  -> (deliver) synthetic_2_down_13

- *	<>  -> (deliver) synthetic_2_down_13

- *	k   -> (deliver) synthetic_2_down_13

- *

- *  synthetic_2_down_3 (button 3 is down)

- *	v1  -> (deliver) synthetic_2_down_3

- *	^1  -> (deliver) synthetic_2_down_3

- *	v2  -> synthetic_2_down_3

- *	^2  -> synthetic_2_down_3

- *	^3  -> start

- *	vo  -> (deliver) synthetic_2_down_3

- *	^o  -> (deliver) synthetic_2_down_3

- *	<>  -> (deliver) synthetic_2_down_3

- *	k   -> (deliver) synthetic_2_down_3

- *

- *  synthetic_2_down_1 (button 1 is down)

- *	^1  -> start

- *	v2  -> synthetic_2_down_1

- *	^2  -> synthetic_2_down_1

- *	v3  -> (deliver) synthetic_2_down_1

- *	^3  -> (deliver) synthetic_2_down_1

- *	vo  -> (deliver) synthetic_2_down_1

- *	^o  -> (deliver) synthetic_2_down_1

- *	<>  -> (deliver) synthetic_2_down_1

- *	k   -> (deliver) synthetic_2_down_1

- */

-

-typedef enum _inputClass {

-    down_1, up_1,

-    down_2, up_2,

-    down_3, up_3,

-    down_o, up_o,

-    motion, outside_box,

-    keyboard, timeout,

-    num_input_class

-} KdInputClass;

-

-typedef enum _inputAction {

-    noop,

-    hold,

-    setto,

-    deliver,

-    release,

-    clearto,

-    gen_down_2,

-    gen_up_2

-} KdInputAction;

-

-#define MAX_ACTIONS 2

-

-typedef struct _inputTransition {

-    KdInputAction  actions[MAX_ACTIONS];

-    KdPointerState nextState;

-} KdInputTransition;

-

-static const

-KdInputTransition  kdInputMachine[num_input_states][num_input_class] = {

-    /* start */

-    {

-	{ { hold, setto },	    button_1_pend },	/* v1 */

-	{ { deliver, noop },	    start },		/* ^1 */

-	{ { deliver, noop },	    button_2_down },	/* v2 */

-	{ { deliver, noop },	    start },		/* ^2 */

-	{ { hold, setto },	    button_3_pend },	/* v3 */

-	{ { deliver, noop },	    start },		/* ^3 */

-	{ { deliver, noop },	    start },		/* vo */

-	{ { deliver, noop },	    start },		/* ^o */

-	{ { deliver, noop },	    start },		/* <> */

-	{ { deliver, noop },	    start },		/* <-> */

-	{ { noop, noop },	    start },		/* k */

-	{ { noop, noop },	    start },		/* ... */

-    },

-    /* button_1_pend */

-    {

-	{ { noop, noop },	    button_1_pend },	/* v1 */

-	{ { release, deliver },	    start },		/* ^1 */

-	{ { release, deliver },	    button_1_down },	/* v2 */

-	{ { release, deliver },	    button_1_down },	/* ^2 */

-	{ { clearto, gen_down_2 },  synth_2_down_13 },	/* v3 */

-	{ { release, deliver },	    button_1_down },	/* ^3 */

-	{ { release, deliver },	    button_1_down },	/* vo */

-	{ { release, deliver },	    button_1_down },	/* ^o */

-	{ { deliver, noop },	    button_1_pend },	/* <> */

-	{ { release, deliver },	    button_1_down },	/* <-> */

-	{ { noop, noop },	    button_1_down },	/* k */

-	{ { release, noop },	    button_1_down },	/* ... */

-    },

-    /* button_1_down */

-    {

-	{ { noop, noop },	    button_1_down },	/* v1 */

-	{ { deliver, noop },	    start },		/* ^1 */

-	{ { deliver, noop },	    button_1_down },	/* v2 */

-	{ { deliver, noop },	    button_1_down },	/* ^2 */

-	{ { deliver, noop },	    button_1_down },	/* v3 */

-	{ { deliver, noop },	    button_1_down },	/* ^3 */

-	{ { deliver, noop },	    button_1_down },	/* vo */

-	{ { deliver, noop },	    button_1_down },	/* ^o */

-	{ { deliver, noop },	    button_1_down },	/* <> */

-	{ { deliver, noop },	    button_1_down },	/* <-> */

-	{ { noop, noop },	    button_1_down },	/* k */

-	{ { noop, noop },	    button_1_down },	/* ... */

-    },

-    /* button_2_down */

-    {

-	{ { deliver, noop },	    button_2_down },	/* v1 */

-	{ { deliver, noop },	    button_2_down },	/* ^1 */

-	{ { noop, noop },	    button_2_down },	/* v2 */

-	{ { deliver, noop },	    start },		/* ^2 */

-	{ { deliver, noop },	    button_2_down },	/* v3 */

-	{ { deliver, noop },	    button_2_down },	/* ^3 */

-	{ { deliver, noop },	    button_2_down },	/* vo */

-	{ { deliver, noop },	    button_2_down },	/* ^o */

-	{ { deliver, noop },	    button_2_down },	/* <> */

-	{ { deliver, noop },	    button_2_down },	/* <-> */

-	{ { noop, noop },	    button_2_down },	/* k */

-	{ { noop, noop },	    button_2_down },	/* ... */

-    },

-    /* button_3_pend */

-    {

-	{ { clearto, gen_down_2 },  synth_2_down_13 },	/* v1 */

-	{ { release, deliver },	    button_3_down },	/* ^1 */

-	{ { release, deliver },	    button_3_down },	/* v2 */

-	{ { release, deliver },	    button_3_down },	/* ^2 */

-	{ { release, deliver },	    button_3_down },	/* v3 */

-	{ { release, deliver },	    start },		/* ^3 */

-	{ { release, deliver },	    button_3_down },	/* vo */

-	{ { release, deliver },	    button_3_down },	/* ^o */

-	{ { deliver, noop },	    button_3_pend },	/* <> */

-	{ { release, deliver },	    button_3_down },	/* <-> */

-	{ { release, noop },	    button_3_down },	/* k */

-	{ { release, noop },	    button_3_down },	/* ... */

-    },

-    /* button_3_down */

-    {

-	{ { deliver, noop },	    button_3_down },	/* v1 */

-	{ { deliver, noop },	    button_3_down },	/* ^1 */

-	{ { deliver, noop },	    button_3_down },	/* v2 */

-	{ { deliver, noop },	    button_3_down },	/* ^2 */

-	{ { noop, noop },	    button_3_down },	/* v3 */

-	{ { deliver, noop },	    start },		/* ^3 */

-	{ { deliver, noop },	    button_3_down },	/* vo */

-	{ { deliver, noop },	    button_3_down },	/* ^o */

-	{ { deliver, noop },	    button_3_down },	/* <> */

-	{ { deliver, noop },	    button_3_down },	/* <-> */

-	{ { noop, noop },	    button_3_down },	/* k */

-	{ { noop, noop },	    button_3_down },	/* ... */

-    },

-    /* synthetic_2_down_13 */

-    {

-	{ { noop, noop },	    synth_2_down_13 },	/* v1 */

-	{ { gen_up_2, noop },	    synth_2_down_3 },	/* ^1 */

-	{ { noop, noop },	    synth_2_down_13 },	/* v2 */

-	{ { noop, noop },	    synth_2_down_13 },	/* ^2 */

-	{ { noop, noop },	    synth_2_down_13 },	/* v3 */

-	{ { gen_up_2, noop },	    synth_2_down_1 },	/* ^3 */

-	{ { deliver, noop },	    synth_2_down_13 },	/* vo */

-	{ { deliver, noop },	    synth_2_down_13 },	/* ^o */

-	{ { deliver, noop },	    synth_2_down_13 },	/* <> */

-	{ { deliver, noop },	    synth_2_down_13 },	/* <-> */

-	{ { noop, noop },	    synth_2_down_13 },	/* k */

-	{ { noop, noop },	    synth_2_down_13 },	/* ... */

-    },

-    /* synthetic_2_down_3 */

-    {

-	{ { deliver, noop },	    synth_2_down_3 },	/* v1 */

-	{ { deliver, noop },	    synth_2_down_3 },	/* ^1 */

-	{ { deliver, noop },	    synth_2_down_3 },	/* v2 */

-	{ { deliver, noop },	    synth_2_down_3 },	/* ^2 */

-	{ { noop, noop },	    synth_2_down_3 },	/* v3 */

-	{ { noop, noop },	    start },		/* ^3 */

-	{ { deliver, noop },	    synth_2_down_3 },	/* vo */

-	{ { deliver, noop },	    synth_2_down_3 },	/* ^o */

-	{ { deliver, noop },	    synth_2_down_3 },	/* <> */

-	{ { deliver, noop },	    synth_2_down_3 },	/* <-> */

-	{ { noop, noop },	    synth_2_down_3 },	/* k */

-	{ { noop, noop },	    synth_2_down_3 },	/* ... */

-    },

-    /* synthetic_2_down_1 */

-    {

-	{ { noop, noop },	    synth_2_down_1 },	/* v1 */

-	{ { noop, noop },	    start },		/* ^1 */

-	{ { deliver, noop },	    synth_2_down_1 },	/* v2 */

-	{ { deliver, noop },	    synth_2_down_1 },	/* ^2 */

-	{ { deliver, noop },	    synth_2_down_1 },	/* v3 */

-	{ { deliver, noop },	    synth_2_down_1 },	/* ^3 */

-	{ { deliver, noop },	    synth_2_down_1 },	/* vo */

-	{ { deliver, noop },	    synth_2_down_1 },	/* ^o */

-	{ { deliver, noop },	    synth_2_down_1 },	/* <> */

-	{ { deliver, noop },	    synth_2_down_1 },	/* <-> */

-	{ { noop, noop },	    synth_2_down_1 },	/* k */

-	{ { noop, noop },	    synth_2_down_1 },	/* ... */

-    },

-};

-

-#define EMULATION_WINDOW    10

-#define EMULATION_TIMEOUT   100

-

-static int

-KdInsideEmulationWindow (KdPointerInfo *pi, int x, int y, int z)

-{

-    pi->emulationDx = pi->heldEvent.x - x;

-    pi->emulationDy = pi->heldEvent.y - y;

-

-    return (abs (pi->emulationDx) < EMULATION_WINDOW &&

-	    abs (pi->emulationDy) < EMULATION_WINDOW);

-}

-

-static KdInputClass

-KdClassifyInput (KdPointerInfo *pi, int type, int x, int y, int z, int b)

-{

-    switch (type) {

-    case ButtonPress:

-	switch (b) {

-	case 1: return down_1;

-	case 2: return down_2;

-	case 3: return down_3;

-	default: return down_o;

-	}

-	break;

-    case ButtonRelease:

-	switch (b) {

-	case 1: return up_1;

-	case 2: return up_2;

-	case 3: return up_3;

-	default: return up_o;

-	}

-	break;

-    case MotionNotify:

-	if (pi->eventHeld && !KdInsideEmulationWindow(pi, x, y, z))

-	    return outside_box;

-	else

-	    return motion;

-    default:

-	return keyboard;

-    }

-    return keyboard;

-}

-

-#ifdef DEBUG

-char	*kdStateNames[] = {

-    "start",

-    "button_1_pend",

-    "button_1_down",

-    "button_2_down",

-    "button_3_pend",

-    "button_3_down",

-    "synth_2_down_13",

-    "synth_2_down_3",

-    "synthetic_2_down_1",

-    "num_input_states"

-};

-

-char	*kdClassNames[] = {

-    "down_1", "up_1",

-    "down_2", "up_2",

-    "down_3", "up_3",

-    "motion", "ouside_box",

-    "keyboard", "timeout",

-    "num_input_class"

-};

-

-char *kdActionNames[] = {

-    "noop",

-    "hold",

-    "setto",

-    "deliver",

-    "release",

-    "clearto",

-    "gen_down_2",

-    "gen_up_2",

-};

-#endif /* DEBUG */

-

-static void

-KdQueueEvent (DeviceIntPtr pDev, InternalEvent *ev)

-{

-    KdAssertSigioBlocked ("KdQueueEvent");

-    mieqEnqueue (pDev, ev);

-}

-

-/* We return true if we're stealing the event. */

-static Bool

-KdRunMouseMachine (KdPointerInfo *pi, KdInputClass c, int type, int x, int y,

-                   int z, int b, int absrel)

-{

-    const KdInputTransition *t;

-    int	a;

-

-    c = KdClassifyInput(pi, type, x, y, z, b);

-    t = &kdInputMachine[pi->mouseState][c];

-    for (a = 0; a < MAX_ACTIONS; a++)

-    {

-	switch (t->actions[a]) {

-	case noop:

-	    break;

-	case hold:

-	    pi->eventHeld = TRUE;

-	    pi->emulationDx = 0;

-	    pi->emulationDy = 0;

-	    pi->heldEvent.type = type;

-            pi->heldEvent.x = x;

-            pi->heldEvent.y = y;

-            pi->heldEvent.z = z;

-            pi->heldEvent.flags = b;

-            pi->heldEvent.absrel = absrel;

-            return TRUE;

-	    break;

-	case setto:

-	    pi->emulationTimeout = GetTimeInMillis () + EMULATION_TIMEOUT;

-	    pi->timeoutPending = TRUE;

-	    break;

-	case deliver:

-            _KdEnqueuePointerEvent (pi, pi->heldEvent.type, pi->heldEvent.x,

-                                    pi->heldEvent.y, pi->heldEvent.z,

-                                    pi->heldEvent.flags, pi->heldEvent.absrel,

-                                    TRUE);

-	    break;

-	case release:

-	    pi->eventHeld = FALSE;

-	    pi->timeoutPending = FALSE;

-            _KdEnqueuePointerEvent (pi, pi->heldEvent.type, pi->heldEvent.x,

-                                    pi->heldEvent.y, pi->heldEvent.z,

-                                    pi->heldEvent.flags, pi->heldEvent.absrel,

-                                    TRUE);

-            return TRUE;

-	    break;

-	case clearto:

-	    pi->timeoutPending = FALSE;

-	    break;

-	case gen_down_2:

-            _KdEnqueuePointerEvent (pi, ButtonPress, x, y, z, 2, absrel,

-                                    TRUE);

-	    pi->eventHeld = FALSE;

-            return TRUE;

-	    break;

-	case gen_up_2:

-            _KdEnqueuePointerEvent (pi, ButtonRelease, x, y, z, 2, absrel,

-                                    TRUE);

-            return TRUE;

-	    break;

-	}

-    }

-    pi->mouseState = t->nextState;

-    return FALSE;

-}

-

-static int

-KdHandlePointerEvent (KdPointerInfo *pi, int type, int x, int y, int z, int b,

-                      int absrel)

-{

-    if (pi->emulateMiddleButton)

-        return KdRunMouseMachine (pi, KdClassifyInput(pi, type, x, y, z, b),

-                                  type, x, y, z, b, absrel);

-    return FALSE;

-}

-

-static void

-KdReceiveTimeout (KdPointerInfo *pi)

-{

-    KdRunMouseMachine (pi, timeout, 0, 0, 0, 0, 0, 0);

-}

-

-/*

- * kdCheckTermination

- *

- * This function checks for the key sequence that terminates the server.  When

- * detected, it sets the dispatchException flag and returns.  The key sequence

- * is:

- *	Control-Alt

- * It's assumed that the server will be waken up by the caller when this

- * function returns.

- */

-

-extern int nClients;

-

-void

-KdReleaseAllKeys (void)

-{

-#if 0

-    int	key;

-    KdKeyboardInfo *ki;

-

-    KdBlockSigio ();

-

-    for (ki = kdKeyboards; ki; ki = ki->next) {

-        for (key = ki->keySyms.minKeyCode; key < ki->keySyms.maxKeyCode;

-             key++) {

-            if (key_is_down(ki->dixdev, key, KEY_POSTED | KEY_PROCESSED)) {

-                KdHandleKeyboardEvent(ki, KeyRelease, key);

-                QueueGetKeyboardEvents(ki->dixdev, KeyRelease, key, NULL);

-            }

-        }

-    }

-

-    KdUnblockSigio ();

-#endif

-}

-

-static void

-KdCheckLock (void)

-{

-    KeyClassPtr	    keyc = NULL;

-    Bool	    isSet = FALSE, shouldBeSet = FALSE;

-    KdKeyboardInfo     *tmp = NULL;

-

-    for (tmp = kdKeyboards; tmp; tmp = tmp->next) {

-        if (tmp->LockLed && tmp->dixdev && tmp->dixdev->key) {

-            keyc = tmp->dixdev->key;

-            isSet = (tmp->leds & (1 << (tmp->LockLed-1))) != 0;

-            /* FIXME: Just use XKB indicators! */

-            shouldBeSet = !!(XkbStateFieldFromRec(&keyc->xkbInfo->state) & LockMask);

-            if (isSet != shouldBeSet)

-                KdSetLed (tmp, tmp->LockLed, shouldBeSet);

-        }

-    }

-}

-

-void

-KdEnqueueKeyboardEvent(KdKeyboardInfo   *ki,

-                       unsigned char scan_code,

-		       unsigned char is_up)

-{

-    unsigned char key_code;

-    KeyClassPtr	keyc = NULL;

-    KeybdCtrl *ctrl = NULL;

-    int type;

-

-    if (!ki || !ki->dixdev || !ki->dixdev->kbdfeed || !ki->dixdev->key)

-	return;

-

-    keyc = ki->dixdev->key;

-    ctrl = &ki->dixdev->kbdfeed->ctrl;

-

-    if (scan_code >= ki->minScanCode && scan_code <= ki->maxScanCode)

-    {

-	key_code = scan_code + KD_MIN_KEYCODE - ki->minScanCode;

-

-	/*

-	 * Set up this event -- the type may be modified below

-	 */

-	if (is_up)

-	    type = KeyRelease;

-	else

-	    type = KeyPress;

-

-        QueueKeyboardEvents(ki->dixdev, type, key_code, NULL);

-    }

-    else {

-        ErrorF("driver %s wanted to post scancode %d outside of [%d, %d]!\n",

-               ki->name, scan_code, ki->minScanCode, ki->maxScanCode);

-    }

-}

-

-/*

- * kdEnqueuePointerEvent

- *

- * This function converts hardware mouse event information into X event

- * information.  A mouse movement event is passed off to MI to generate

- * a MotionNotify event, if appropriate.  Button events are created and

- * passed off to MI for enqueueing.

- */

-

-/* FIXME do something a little more clever to deal with multiple axes here */

-void

-KdEnqueuePointerEvent(KdPointerInfo *pi, unsigned long flags, int rx, int ry,

-                      int rz)

-{

-    CARD32        ms;

-    unsigned char buttons;

-    int           x, y, z;

-    int           (*matrix)[3] = kdPointerMatrix.matrix;

-    unsigned long button;

-    int           n;

-    int           dixflags = 0;

-

-    if (!pi)

-	return;

-

-    ms = GetTimeInMillis();

-

-    /* we don't need to transform z, so we don't. */

-    if (flags & KD_MOUSE_DELTA) {

-	if (pi->transformCoordinates) {

-	    x = matrix[0][0] * rx + matrix[0][1] * ry;

-	    y = matrix[1][0] * rx + matrix[1][1] * ry;

-	}

-	else {

-	    x = rx;

-	    y = ry;

-	}

-    }

-    else {

-	if (pi->transformCoordinates) {

-	    x = matrix[0][0] * rx + matrix[0][1] * ry + matrix[0][2];

-	    y = matrix[1][0] * rx + matrix[1][1] * ry + matrix[1][2];

-	}

-	else {

-	    x = rx;

-	    y = ry;

-	}

-    }

-    z = rz;

-

-    if (flags & KD_MOUSE_DELTA)

-    {

-        if (x || y || z)

-        {

-            dixflags = POINTER_RELATIVE | POINTER_ACCELERATE;

-            _KdEnqueuePointerEvent(pi, MotionNotify, x, y, z, 0, dixflags, FALSE);

-        }

-    } else

-    {

-        dixflags = POINTER_ABSOLUTE;

-        if (x != pi->dixdev->last.valuators[0] ||

-            y != pi->dixdev->last.valuators[1])

-            _KdEnqueuePointerEvent(pi, MotionNotify, x, y, z, 0, dixflags, FALSE);

-    }

-

-    buttons = flags;

-

-    for (button = KD_BUTTON_1, n = 1; n <= pi->nButtons;

-         button <<= 1, n++) {

-        if (((pi->buttonState & button) ^ (buttons & button)) &&

-           !(buttons & button)) {

-            _KdEnqueuePointerEvent(pi, ButtonRelease, x, y, z, n,

-                                   dixflags, FALSE);

-	}

-    }

-    for (button = KD_BUTTON_1, n = 1; n <= pi->nButtons;

-         button <<= 1, n++) {

-	if (((pi->buttonState & button) ^ (buttons & button)) &&

-	    (buttons & button)) {

-            _KdEnqueuePointerEvent(pi, ButtonPress, x, y, z, n,

-                                   dixflags, FALSE);

-        }

-    }

-

-    pi->buttonState = buttons;

-}

-

-void

-_KdEnqueuePointerEvent (KdPointerInfo *pi, int type, int x, int y, int z,

-                        int b, int absrel, Bool force)

-{

-    int valuators[3] = { x, y, z };

-    ValuatorMask mask;

-

-    /* TRUE from KdHandlePointerEvent, means 'we swallowed the event'. */

-    if (!force && KdHandlePointerEvent(pi, type, x, y, z, b, absrel))

-        return;

-

-    valuator_mask_set_range(&mask, 0, 3, valuators);

-

-    QueuePointerEvents(pi->dixdev, type, b, absrel, &mask);

-}

-

-void

-KdBlockHandler (int		screen,

-		pointer		blockData,

-		pointer		timeout,

-		pointer		readmask)

-{

-    KdPointerInfo		    *pi;

-    int myTimeout=0;

-

-    for (pi = kdPointers; pi; pi = pi->next)

-    {

-	if (pi->timeoutPending)

-	{

-	    int	ms;

-

-	    ms = pi->emulationTimeout - GetTimeInMillis ();

-	    if (ms < 1)

-		ms = 1;

-	    if(ms<myTimeout || myTimeout==0)

-		    myTimeout=ms;

-	}

-    }

-    /* if we need to poll for events, do that */

-    if(kdOsFuncs->pollEvents)

-    {

-	    (*kdOsFuncs->pollEvents)();

-	    myTimeout=20;

-    }

-    if(myTimeout>0)

-    	AdjustWaitForDelay (timeout, myTimeout);

-}

-

-void

-KdWakeupHandler (int		screen,

-		 pointer    	data,

-		 unsigned long	lresult,

-		 pointer	readmask)

-{

-    int		result = (int) lresult;

-    fd_set	*pReadmask = (fd_set *) readmask;

-    int		i;

-    KdPointerInfo	*pi;

-

-    if (kdInputEnabled && result > 0)

-    {

-	for (i = 0; i < kdNumInputFds; i++)

-	    if (FD_ISSET (kdInputFds[i].fd, pReadmask))

-	    {

-		KdBlockSigio ();

-		(*kdInputFds[i].read) (kdInputFds[i].fd, kdInputFds[i].closure);

-		KdUnblockSigio ();

-	    }

-    }

-    for (pi = kdPointers; pi; pi = pi->next)

-    {

-	if (pi->timeoutPending)

-	{

-	    if ((long) (GetTimeInMillis () - pi->emulationTimeout) >= 0)

-	    {

-		pi->timeoutPending = FALSE;

-		KdBlockSigio ();

-		KdReceiveTimeout (pi);

-		KdUnblockSigio ();

-	    }

-	}

-    }

-    if (kdSwitchPending)

-	KdProcessSwitch ();

-}

-

-#define KdScreenOrigin(pScreen) (&(KdGetScreenPriv(pScreen)->screen->origin))

-

-static Bool

-KdCursorOffScreen(ScreenPtr *ppScreen, int *x, int *y)

-{

-    ScreenPtr	pScreen  = *ppScreen;

-    ScreenPtr	pNewScreen;

-    int		n;

-    int		dx, dy;

-    int		best_x, best_y;

-    int		n_best_x, n_best_y;

-    CARD32	ms;

-

-    if (kdDisableZaphod || screenInfo.numScreens <= 1)

-	return FALSE;

-

-    if (0 <= *x && *x < pScreen->width && 0 <= *y && *y < pScreen->height)

-	return FALSE;

-

-    ms = GetTimeInMillis ();

-    if (kdOffScreen && (int) (ms - kdOffScreenTime) < 1000)

-	return FALSE;

-    kdOffScreen = TRUE;

-    kdOffScreenTime = ms;

-    n_best_x = -1;

-    best_x = 32767;

-    n_best_y = -1;

-    best_y = 32767;

-    for (n = 0; n < screenInfo.numScreens; n++)

-    {

-	pNewScreen = screenInfo.screens[n];

-	if (pNewScreen == pScreen)

-	    continue;

-	dx = KdScreenOrigin(pNewScreen)->x - KdScreenOrigin(pScreen)->x;

-	dy = KdScreenOrigin(pNewScreen)->y - KdScreenOrigin(pScreen)->y;

-	if (*x < 0)

-	{

-	    if (dx <= 0 && -dx < best_x)

-	    {

-		best_x = -dx;

-		n_best_x = n;

-	    }

-	}

-	else if (*x >= pScreen->width)

-	{

-	    if (dx >= 0 && dx < best_x)

-	    {

-		best_x = dx;

-		n_best_x = n;

-	    }

-	}

-	if (*y < 0)

-	{

-	    if (dy <= 0 && -dy < best_y)

-	    {

-		best_y = -dy;

-		n_best_y = n;

-	    }

-	}

-	else if (*y >= pScreen->height)

-	{

-	    if (dy >= 0 && dy < best_y)

-	    {

-		best_y = dy;

-		n_best_y = n;

-	    }

-	}

-    }

-    if (best_y < best_x)

-	n_best_x = n_best_y;

-    if (n_best_x == -1)

-	return FALSE;

-    pNewScreen = screenInfo.screens[n_best_x];

-

-    if (*x < 0)

-	*x += pNewScreen->width;

-    if (*y < 0)

-	*y += pNewScreen->height;

-

-    if (*x >= pScreen->width)

-	*x -= pScreen->width;

-    if (*y >= pScreen->height)

-	*y -= pScreen->height;

-

-    *ppScreen = pNewScreen;

-    return TRUE;

-}

-

-static void

-KdCrossScreen(ScreenPtr pScreen, Bool entering)

-{

-#ifndef XIPAQ

-    if (entering)

-	KdEnableScreen (pScreen);

-    else

-	KdDisableScreen (pScreen);

-#endif

-}

-

-int KdCurScreen;	/* current event screen */

-

-static void

-KdWarpCursor (DeviceIntPtr pDev, ScreenPtr pScreen, int x, int y)

-{

-    KdBlockSigio ();

-    KdCurScreen = pScreen->myNum;

-    miPointerWarpCursor(pDev, pScreen, x, y);

-    KdUnblockSigio ();

-}

-

-miPointerScreenFuncRec kdPointerScreenFuncs =

-{

-    KdCursorOffScreen,

-    KdCrossScreen,

-    KdWarpCursor

-};

-

-#ifndef _MSC_VER

-void

-ProcessInputEvents (void)

-{

-    mieqProcessInputEvents();

-    if (kdSwitchPending)

-	KdProcessSwitch ();

-    KdCheckLock ();

-}

-#endif

-

-/* At the moment, absolute/relative is up to the client. */

-int

-SetDeviceMode(register ClientPtr client, DeviceIntPtr pDev, int mode)

-{

-    return BadMatch;

-}

-

-int

-SetDeviceValuators(register ClientPtr client, DeviceIntPtr pDev,

-                   int *valuators, int first_valuator, int num_valuators)

-{

-    return BadMatch;

-}

-

-int

-ChangeDeviceControl(register ClientPtr client, DeviceIntPtr pDev,

-                        xDeviceCtl *control)

-{

-    switch (control->control) {

-    case DEVICE_RESOLUTION:

-        /* FIXME do something more intelligent here */

-        return BadMatch;

-

-    case DEVICE_ABS_CALIB:

-    case DEVICE_ABS_AREA:

-    case DEVICE_CORE:

-        return BadMatch;

-    case DEVICE_ENABLE:

-        return Success;

-

-    default:

-        return BadMatch;

-    }

-

-    /* NOTREACHED */

-    return BadImplementation;

-}

-

-int

-NewInputDeviceRequest(InputOption *options, InputAttributes *attrs,

-                      DeviceIntPtr *pdev)

-{

-    InputOption *option = NULL;

-    KdPointerInfo *pi = NULL;

-    KdKeyboardInfo *ki = NULL;

-

-    for (option = options; option; option = option->next) {

-        if (strcmp(option->key, "type") == 0) {

-            if (strcmp(option->value, "pointer") == 0) {

-                pi = KdNewPointer();

-                if (!pi)

-                    return BadAlloc;

-            }

-            else if (strcmp(option->value, "keyboard") == 0) {

-                ki = KdNewKeyboard();

-                if (!ki)

-                    return BadAlloc;

-            }

-            else {

-                ErrorF("unrecognised device type!\n");

-                return BadValue;

-            }

-        }

-#ifdef CONFIG_HAL

-        else if (strcmp(option->key, "_source") == 0 &&

-                 strcmp(option->value, "server/hal") == 0)

-        {

-            ErrorF("Ignoring device from HAL.\n");

-            return BadValue;

-        }

-#endif

-#ifdef CONFIG_UDEV

-        else if (strcmp(option->key, "_source") == 0 &&

-                 strcmp(option->value, "server/udev") == 0)

-        {

-            ErrorF("Ignoring device from udev.\n");

-            return BadValue;

-        }

-#endif

-    }

-

-    if (!ki && !pi) {

-        ErrorF("unrecognised device identifier!\n");

-        return BadValue;

-    }

-

-    /* FIXME: change this code below to use KdParseKbdOptions and

-     * KdParsePointerOptions */

-    for (option = options; option; option = option->next) {

-        if (strcmp(option->key, "device") == 0) {

-            if (pi && option->value)

-                pi->path = strdup(option->value);

-            else if (ki && option->value)

-                ki->path = strdup(option->value);

-        }

-        else if (strcmp(option->key, "driver") == 0) {

-            if (pi) {

-                pi->driver = KdFindPointerDriver(option->value);

-                if (!pi->driver) {

-                    ErrorF("couldn't find driver!\n");

-                    KdFreePointer(pi);

-                    return BadValue;

-                }

-                pi->options = options;

-            }

-            else if (ki) {

-                ki->driver = KdFindKeyboardDriver(option->value);

-                if (!ki->driver) {

-                    ErrorF("couldn't find driver!\n");

-                    KdFreeKeyboard(ki);

-                    return BadValue;

-                }

-                ki->options = options;

-            }

-        }

-    }

-

-    if (pi) {

-        if (KdAddPointer(pi) != Success ||

-            ActivateDevice(pi->dixdev, TRUE) != Success ||

-            EnableDevice(pi->dixdev, TRUE) != TRUE) {

-            ErrorF("couldn't add or enable pointer\n");

-            return BadImplementation;

-        }

-    }

-    else if (ki) {

-        if (KdAddKeyboard(ki) != Success ||

-            ActivateDevice(ki->dixdev, TRUE) != Success ||

-            EnableDevice(ki->dixdev, TRUE) != TRUE) {

-            ErrorF("couldn't add or enable keyboard\n");

-            return BadImplementation;

-        }

-    }

-

-    if (pi) {

-        *pdev = pi->dixdev;

-    } else if(ki) {

-        *pdev = ki->dixdev;

-    }

-

-    return Success;

-}

-

-void

-DeleteInputDeviceRequest(DeviceIntPtr pDev)

-{

-    RemoveDevice(pDev, TRUE);

-}

+/*
+ * Copyright © 1999 Keith Packard
+ * Copyright © 2006 Nokia Corporation
+ *
+ * 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 the authors not be used in
+ * advertising or publicity pertaining to distribution of the software without
+ * specific, written prior permission.  The authors make no
+ * representations about the suitability of this software for any purpose.  It
+ * is provided "as is" without express or implied warranty.
+ *
+ * THE AUTHORS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
+ * EVENT SHALL THE AUTHORS 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_CONFIG_H
+#include <kdrive-config.h>
+#endif
+#include "kdrive.h"
+#include "inputstr.h"
+
+#define XK_PUBLISHING
+#include <X11/keysym.h>
+#if HAVE_X11_XF86KEYSYM_H
+#include <X11/XF86keysym.h>
+#endif
+#include <signal.h>
+#include <stdio.h>
+#ifdef sun
+#include <sys/file.h> /* needed for FNONBLOCK & FASYNC */
+#endif
+
+#include "xkbsrv.h"
+
+#include <X11/extensions/XI.h>
+#include <X11/extensions/XIproto.h>
+#include "XIstubs.h" /* even though we don't use stubs.  cute, no? */
+#include "exevents.h"
+#include "extinit.h"
+#include "exglobals.h"
+#include "eventstr.h"
+#include "xserver-properties.h"
+#include "inpututils.h"
+
+#define AtomFromName(x) MakeAtom(x, strlen(x), 1)
+
+struct KdConfigDevice {
+    char *line;
+    struct KdConfigDevice *next;
+};
+
+/* kdKeyboards and kdPointers hold all the real devices. */
+static KdKeyboardInfo *kdKeyboards         = NULL;
+static KdPointerInfo  *kdPointers          = NULL;
+static struct KdConfigDevice *kdConfigKeyboards   = NULL;
+static struct KdConfigDevice *kdConfigPointers    = NULL;
+
+static KdKeyboardDriver *kdKeyboardDrivers = NULL;
+static KdPointerDriver  *kdPointerDrivers  = NULL;
+
+static Bool		kdInputEnabled;
+static Bool		kdOffScreen;
+static unsigned long	kdOffScreenTime;
+static KdPointerMatrix	kdPointerMatrix = {
+   { { 1, 0, 0 },
+     { 0, 1, 0 } }
+};
+
+void KdResetInputMachine (void);
+
+#define KD_MAX_INPUT_FDS    8
+
+typedef struct _kdInputFd {
+    int	        fd;
+    void        (*read) (int fd, void *closure);
+    int	        (*enable) (int fd, void *closure);
+    void        (*disable) (int fd, void *closure);
+    void        *closure;
+} KdInputFd;
+
+static KdInputFd kdInputFds[KD_MAX_INPUT_FDS];
+static int	 kdNumInputFds;
+
+extern Bool      kdRawPointerCoordinates;
+
+static void
+KdSigio (int sig)
+{
+    int	i;
+
+    for (i = 0; i < kdNumInputFds; i++)
+	(*kdInputFds[i].read) (kdInputFds[i].fd, kdInputFds[i].closure);
+}
+
+static void
+KdBlockSigio (void)
+{
+#ifdef _MSC_VER
+    __asm int 3;
+#else
+    sigset_t	set;
+
+    sigemptyset (&set);
+    sigaddset (&set, SIGIO);
+    sigprocmask (SIG_BLOCK, &set, 0);
+#endif
+}
+
+static void
+KdUnblockSigio (void)
+{
+#ifdef _MSC_VER
+    __asm int 3;
+#else
+    sigset_t	set;
+
+    sigemptyset (&set);
+    sigaddset (&set, SIGIO);
+    sigprocmask (SIG_UNBLOCK, &set, 0);
+#endif
+}
+
+#ifdef DEBUG_SIGIO
+
+void
+KdAssertSigioBlocked (char *where)
+{
+    sigset_t	set, old;
+
+    sigemptyset (&set);
+    sigprocmask (SIG_BLOCK, &set, &old);
+    if (!sigismember (&old, SIGIO)) {
+	ErrorF ("SIGIO not blocked at %s\n", where);
+        KdBacktrace(0);
+    }
+}
+
+#else
+
+#define KdAssertSigioBlocked(s)
+
+#endif
+
+static int  kdnFds;
+
+#ifdef FNONBLOCK
+#define NOBLOCK FNONBLOCK
+#else
+#define NOBLOCK FNDELAY
+#endif
+
+void
+KdResetInputMachine (void)
+{
+    KdPointerInfo *pi;
+
+    for (pi = kdPointers; pi; pi = pi->next) {
+        pi->mouseState = start;
+        pi->eventHeld = FALSE;
+    }
+}
+
+static void
+KdNonBlockFd (int fd)
+{
+#ifdef _MSC_VER
+    __asm int 3;
+#else
+    int	flags;
+    flags = fcntl (fd, F_GETFL);
+    flags |= FASYNC|NOBLOCK;
+    fcntl (fd, F_SETFL, flags);
+#endif
+}
+
+static void
+KdAddFd (int fd)
+{
+#ifdef _MSC_VER
+    __asm int 3;
+#else
+    struct sigaction	act;
+    sigset_t		set;
+
+    kdnFds++;
+    fcntl (fd, F_SETOWN, getpid());
+    KdNonBlockFd (fd);
+    AddEnabledDevice (fd);
+    memset (&act, '\0', sizeof act);
+    act.sa_handler = KdSigio;
+    sigemptyset (&act.sa_mask);
+    sigaddset (&act.sa_mask, SIGIO);
+    sigaddset (&act.sa_mask, SIGALRM);
+    sigaddset (&act.sa_mask, SIGVTALRM);
+    sigaction (SIGIO, &act, 0);
+    sigemptyset (&set);
+    sigprocmask (SIG_SETMASK, &set, 0);
+#endif
+}
+
+static void
+KdRemoveFd (int fd)
+{
+#ifdef _MSC_VER
+    __asm int 3;
+#else
+    struct sigaction	act;
+    int			flags;
+
+    kdnFds--;
+    RemoveEnabledDevice (fd);
+    flags = fcntl (fd, F_GETFL);
+    flags &= ~(FASYNC|NOBLOCK);
+    fcntl (fd, F_SETFL, flags);
+    if (kdnFds == 0)
+    {
+	memset (&act, '\0', sizeof act);
+	act.sa_handler = SIG_IGN;
+	sigemptyset (&act.sa_mask);
+	sigaction (SIGIO, &act, 0);
+    }
+#endif
+}
+
+Bool
+KdRegisterFd (int fd, void (*read) (int fd, void *closure), void *closure)
+{
+    if (kdNumInputFds == KD_MAX_INPUT_FDS)
+	return FALSE;
+    kdInputFds[kdNumInputFds].fd = fd;
+    kdInputFds[kdNumInputFds].read = read;
+    kdInputFds[kdNumInputFds].enable = 0;
+    kdInputFds[kdNumInputFds].disable = 0;
+    kdInputFds[kdNumInputFds].closure = closure;
+    kdNumInputFds++;
+    if (kdInputEnabled)
+	KdAddFd (fd);
+    return TRUE;
+}
+
+void
+KdUnregisterFd (void *closure, int fd, Bool do_close)
+{
+    int	i, j;
+
+    for (i = 0; i < kdNumInputFds; i++) {
+	if (kdInputFds[i].closure == closure &&
+            (fd == -1 || kdInputFds[i].fd == fd)) {
+	    if (kdInputEnabled)
+		KdRemoveFd (kdInputFds[i].fd);
+	    if (do_close)
+		close (kdInputFds[i].fd);
+	    kdNumInputFds--;
+	    for (j = i; j < kdNumInputFds; j++)
+		kdInputFds[j] = kdInputFds[j+1];
+            break;
+	}
+    }
+}
+
+void
+KdUnregisterFds (void *closure, Bool do_close)
+{
+    KdUnregisterFd(closure, -1, do_close);
+}
+
+void
+KdDisableInput (void)
+{
+    KdKeyboardInfo *ki;
+    KdPointerInfo *pi;
+    int found = 0, i = 0;
+
+    KdBlockSigio();
+
+    for (ki = kdKeyboards; ki; ki = ki->next) {
+        if (ki->driver && ki->driver->Disable)
+            (*ki->driver->Disable) (ki);
+    }
+
+    for (pi = kdPointers; pi; pi = pi->next) {
+        if (pi->driver && pi->driver->Disable)
+            (*pi->driver->Disable) (pi);
+    }
+
+    if (kdNumInputFds) {
+        ErrorF("[KdDisableInput] Buggy drivers: still %d input fds left!",
+               kdNumInputFds);
+        i = 0;
+        while (i < kdNumInputFds) {
+            found = 0;
+            for (ki = kdKeyboards; ki; ki = ki->next) {
+                if (ki == kdInputFds[i].closure) {
+                    ErrorF("    fd %d belongs to keybd driver %s\n",
+                           kdInputFds[i].fd,
+                           ki->driver && ki->driver->name ?
+                             ki->driver->name : "(unnamed!)");
+                    found = 1;
+                    break;
+                }
+            }
+
+            if (found) {
+                i++;
+                continue;
+            }
+
+            for (pi = kdPointers; pi; pi = pi->next) {
+                if (pi == kdInputFds[i].closure) {
+                    ErrorF("    fd %d belongs to pointer driver %s\n",
+                           kdInputFds[i].fd,
+                           pi->driver && pi->driver->name ?
+                             pi->driver->name : "(unnamed!)");
+                    break;
+                }
+            }
+
+            if (found) {
+                i++;
+                continue;
+            }
+
+            ErrorF("    fd %d not claimed by any active device!\n",
+                   kdInputFds[i].fd);
+            KdUnregisterFd(kdInputFds[i].closure, kdInputFds[i].fd, TRUE);
+        }
+    }
+
+    kdInputEnabled = FALSE;
+}
+
+void
+KdEnableInput (void)
+{
+    InternalEvent ev;
+    KdKeyboardInfo *ki;
+    KdPointerInfo *pi;
+
+    kdInputEnabled = TRUE;
+
+    for (ki = kdKeyboards; ki; ki = ki->next) {
+        if (ki->driver && ki->driver->Enable)
+            (*ki->driver->Enable) (ki);
+    }
+
+    for (pi = kdPointers; pi; pi = pi->next) {
+        if (pi->driver && pi->driver->Enable)
+            (*pi->driver->Enable) (pi);
+    }
+
+    /* reset screen saver */
+    ev.any.time = GetTimeInMillis ();
+    NoticeEventTime (&ev);
+
+    KdUnblockSigio ();
+}
+
+static KdKeyboardDriver *
+KdFindKeyboardDriver (char *name)
+{
+    KdKeyboardDriver *ret;
+
+    /* ask a stupid question ... */
+    if (!name)
+        return NULL;
+
+    for (ret = kdKeyboardDrivers; ret; ret = ret->next) {
+        if (strcmp(ret->name, name) == 0)
+            return ret;
+    }
+
+    return NULL;
+}
+
+static KdPointerDriver *
+KdFindPointerDriver (char *name)
+{
+    KdPointerDriver *ret;
+
+    /* ask a stupid question ... */
+    if (!name)
+        return NULL;
+
+    for (ret = kdPointerDrivers; ret; ret = ret->next) {
+        if (strcmp(ret->name, name) == 0)
+            return ret;
+    }
+
+    return NULL;
+}
+
+static int
+KdPointerProc(DeviceIntPtr pDevice, int onoff)
+{
+    DevicePtr       pDev = (DevicePtr)pDevice;
+    KdPointerInfo   *pi;
+    Atom            xiclass;
+    Atom            *btn_labels;
+    Atom            *axes_labels;
+
+    if (!pDev)
+	return BadImplementation;
+
+    for (pi = kdPointers; pi; pi = pi->next) {
+        if (pi->dixdev && pi->dixdev->id == pDevice->id)
+            break;
+    }
+
+    if (!pi || !pi->dixdev || pi->dixdev->id != pDevice->id) {
+        ErrorF("[KdPointerProc] Failed to find pointer for device %d!\n",
+               pDevice->id);
+        return BadImplementation;
+    }
+
+    switch (onoff)
+    {
+    case DEVICE_INIT:
+#ifdef DEBUG
+        ErrorF("initialising pointer %s ...\n", pi->name);
+#endif
+        if (!pi->driver) {
+            if (!pi->driverPrivate) {
+                ErrorF("no driver specified for %s\n", pi->name);
+                return BadImplementation;
+            }
+
+            pi->driver = KdFindPointerDriver(pi->driverPrivate);
+            if (!pi->driver) {
+                ErrorF("Couldn't find pointer driver %s\n",
+                       pi->driverPrivate ? (char *) pi->driverPrivate :
+                       "(unnamed)");
+                return !Success;
+            }
+            free(pi->driverPrivate);
+            pi->driverPrivate = NULL;
+        }
+
+        if (!pi->driver->Init) {
+            ErrorF("no init function\n");
+            return BadImplementation;
+        }
+
+        if ((*pi->driver->Init) (pi) != Success) {
+            return !Success;
+        }
+
+	btn_labels = calloc(pi->nButtons, sizeof(Atom));
+	if (!btn_labels)
+	    return BadAlloc;
+	axes_labels = calloc(pi->nAxes, sizeof(Atom));
+	if (!axes_labels) {
+	    free(btn_labels);
+	    return BadAlloc;
+	}
+
+	switch(pi->nAxes)
+	{
+	    default:
+	    case 7:
+		btn_labels[6] = XIGetKnownProperty(BTN_LABEL_PROP_BTN_HWHEEL_RIGHT);
+	    case 6:
+		btn_labels[5] = XIGetKnownProperty(BTN_LABEL_PROP_BTN_HWHEEL_LEFT);
+	    case 5:
+		btn_labels[4] = XIGetKnownProperty(BTN_LABEL_PROP_BTN_WHEEL_DOWN);
+	    case 4:
+		btn_labels[3] = XIGetKnownProperty(BTN_LABEL_PROP_BTN_WHEEL_UP);
+	    case 3:
+		btn_labels[2] = XIGetKnownProperty(BTN_LABEL_PROP_BTN_RIGHT);
+	    case 2:
+		btn_labels[1] = XIGetKnownProperty(BTN_LABEL_PROP_BTN_MIDDLE);
+	    case 1:
+		btn_labels[0] = XIGetKnownProperty(BTN_LABEL_PROP_BTN_LEFT);
+	    case 0:
+		break;
+	}
+
+	if (pi->nAxes >= 2) {
+	    axes_labels[0] = XIGetKnownProperty(AXIS_LABEL_PROP_REL_X);
+	    axes_labels[1] = XIGetKnownProperty(AXIS_LABEL_PROP_REL_Y);
+	}
+
+	InitPointerDeviceStruct(pDev, pi->map, pi->nButtons, btn_labels,
+	    (PtrCtrlProcPtr)NoopDDA,
+	    GetMotionHistorySize(), pi->nAxes, axes_labels);
+
+        free(btn_labels);
+        free(axes_labels);
+
+        if (pi->inputClass == KD_TOUCHSCREEN) {
+            xiclass = AtomFromName(XI_TOUCHSCREEN);
+        }
+        else {
+            xiclass = AtomFromName(XI_MOUSE);
+        }
+
+        AssignTypeAndName(pi->dixdev, xiclass,
+                          pi->name ? pi->name : "Generic KDrive Pointer");
+
+	return Success;
+
+    case DEVICE_ON:
+        if (pDev->on == TRUE)
+            return Success;
+
+        if (!pi->driver->Enable) {
+            ErrorF("no enable function\n");
+            return BadImplementation;
+        }
+
+        if ((*pi->driver->Enable) (pi) == Success) {
+            pDev->on = TRUE;
+            return Success;
+        }
+        else {
+            return BadImplementation;
+        }
+
+	return Success;
+
+    case DEVICE_OFF:
+        if (pDev->on == FALSE) {
+            return Success;
+        }
+
+        if (!pi->driver->Disable) {
+            return BadImplementation;
+        }
+        else {
+            (*pi->driver->Disable) (pi);
+            pDev->on = FALSE;
+            return Success;
+        }
+
+        return Success;
+
+    case DEVICE_CLOSE:
+	if (pDev->on) {
+            if (!pi->driver->Disable) {
+                return BadImplementation;
+            }
+            (*pi->driver->Disable) (pi);
+            pDev->on = FALSE;
+        }
+
+        if (!pi->driver->Fini)
+            return BadImplementation;
+
+        (*pi->driver->Fini) (pi);
+
+        KdRemovePointer(pi);
+
+        return Success;
+    }
+
+    /* NOTREACHED */
+    return BadImplementation;
+}
+
+#ifndef _MSC_VER
+Bool
+LegalModifier(unsigned int key, DeviceIntPtr pDev)
+{
+    return TRUE;
+}
+#endif
+
+static void
+KdBell (int volume, DeviceIntPtr pDev, pointer arg, int something)
+{
+    KeybdCtrl *ctrl = arg;
+    KdKeyboardInfo *ki = NULL;
+
+    for (ki = kdKeyboards; ki; ki = ki->next) {
+        if (ki->dixdev && ki->dixdev->id == pDev->id)
+            break;
+    }
+
+    if (!ki || !ki->dixdev || ki->dixdev->id != pDev->id || !ki->driver)
+        return;
+
+    KdRingBell(ki, volume, ctrl->bell_pitch, ctrl->bell_duration);
+}
+
+#ifndef _MSC_VER
+void
+DDXRingBell(int volume, int pitch, int duration)
+{
+    KdKeyboardInfo *ki = NULL;
+
+    if (kdOsFuncs->Bell) {
+        (*kdOsFuncs->Bell)(volume, pitch, duration);
+    }
+    else {
+        for (ki = kdKeyboards; ki; ki = ki->next) {
+            if (ki->dixdev->coreEvents)
+                KdRingBell(ki, volume, pitch, duration);
+        }
+    }
+}
+#endif
+void
+KdRingBell(KdKeyboardInfo *ki, int volume, int pitch, int duration)
+{
+    if (!ki || !ki->driver || !ki->driver->Bell)
+        return;
+
+    if (kdInputEnabled)
+        (*ki->driver->Bell) (ki, volume, pitch, duration);
+}
+
+
+static void
+KdSetLeds (KdKeyboardInfo *ki, int leds)
+{
+    if (!ki || !ki->driver)
+        return;
+
+    if (kdInputEnabled) {
+        if (ki->driver->Leds)
+            (*ki->driver->Leds) (ki, leds);
+    }
+}
+
+void
+KdSetLed (KdKeyboardInfo *ki, int led, Bool on)
+{
+    if (!ki || !ki->dixdev || !ki->dixdev->kbdfeed)
+        return;
+
+    NoteLedState (ki->dixdev, led, on);
+    KdSetLeds (ki, ki->dixdev->kbdfeed->ctrl.leds);
+}
+
+void
+KdSetPointerMatrix (KdPointerMatrix *matrix)
+{
+    kdPointerMatrix = *matrix;
+}
+
+void
+KdComputePointerMatrix (KdPointerMatrix *m, Rotation randr, int width,
+                        int height)
+{
+    int		    x_dir = 1, y_dir = 1;
+    int		    i, j;
+    int		    size[2];
+
+    size[0] = width; size[1] = height;
+    if (randr & RR_Reflect_X)
+	x_dir = -1;
+    if (randr & RR_Reflect_Y)
+	y_dir = -1;
+    switch (randr & (RR_Rotate_All)) {
+    case RR_Rotate_0:
+	m->matrix[0][0] = x_dir; m->matrix[0][1] = 0;
+	m->matrix[1][0] = 0; m->matrix[1][1] = y_dir;
+	break;
+    case RR_Rotate_90:
+	m->matrix[0][0] = 0; m->matrix[0][1] = -x_dir;
+	m->matrix[1][0] = y_dir; m->matrix[1][1] = 0;
+	break;
+    case RR_Rotate_180:
+	m->matrix[0][0] = -x_dir; m->matrix[0][1] = 0;
+	m->matrix[1][0] = 0; m->matrix[1][1] = -y_dir;
+	break;
+    case RR_Rotate_270:
+	m->matrix[0][0] = 0; m->matrix[0][1] = x_dir;
+	m->matrix[1][0] = -y_dir; m->matrix[1][1] = 0;
+	break;
+    }
+    for (i = 0; i < 2; i++)
+    {
+	m->matrix[i][2] = 0;
+	for (j = 0 ; j < 2; j++)
+	    if (m->matrix[i][j] < 0)
+		m->matrix[i][2] = size[j] - 1;
+    }
+}
+
+void
+KdScreenToPointerCoords (int *x, int *y)
+{
+    int	(*m)[3] = kdPointerMatrix.matrix;
+    int div = m[0][1] * m[1][0] - m[1][1] * m[0][0];
+    int sx = *x;
+    int sy = *y;
+
+    *x = (m[0][1] * sy - m[0][1] * m[1][2] + m[1][1] * m[0][2] - m[1][1] * sx) / div;
+    *y = (m[1][0] * sx + m[0][0] * m[1][2] - m[1][0] * m[0][2] - m[0][0] * sy) / div;
+}
+
+static void
+KdKbdCtrl (DeviceIntPtr pDevice, KeybdCtrl *ctrl)
+{
+    KdKeyboardInfo *ki;
+
+    for (ki = kdKeyboards; ki; ki = ki->next) {
+        if (ki->dixdev && ki->dixdev->id == pDevice->id)
+            break;
+    }
+
+    if (!ki || !ki->dixdev || ki->dixdev->id != pDevice->id || !ki->driver)
+        return;
+
+    KdSetLeds(ki, ctrl->leds);
+    ki->bellPitch = ctrl->bell_pitch;
+    ki->bellDuration = ctrl->bell_duration;
+}
+
+extern KeybdCtrl defaultKeyboardControl;
+
+static int
+KdKeyboardProc(DeviceIntPtr pDevice, int onoff)
+{
+    Bool        ret;
+    DevicePtr   pDev = (DevicePtr)pDevice;
+    KdKeyboardInfo *ki;
+    Atom xiclass;
+    XkbRMLVOSet rmlvo;
+
+    if (!pDev)
+	return BadImplementation;
+
+    for (ki = kdKeyboards; ki; ki = ki->next) {
+        if (ki->dixdev && ki->dixdev->id == pDevice->id)
+            break;
+    }
+
+    if (!ki || !ki->dixdev || ki->dixdev->id != pDevice->id) {
+        return BadImplementation;
+    }
+
+    switch (onoff)
+    {
+    case DEVICE_INIT:
+#ifdef DEBUG
+        ErrorF("initialising keyboard %s\n", ki->name);
+#endif
+        if (!ki->driver) {
+            if (!ki->driverPrivate) {
+                ErrorF("no driver specified!\n");
+                return BadImplementation;
+            }
+
+            ki->driver = KdFindKeyboardDriver(ki->driverPrivate);
+            if (!ki->driver) {
+                ErrorF("Couldn't find keyboard driver %s\n",
+                       ki->driverPrivate ? (char *) ki->driverPrivate :
+                       "(unnamed)");
+                return !Success;
+            }
+            free(ki->driverPrivate);
+            ki->driverPrivate = NULL;
+        }
+
+        if (!ki->driver->Init) {
+            ErrorF("Keyboard %s: no init function\n", ki->name);
+            return BadImplementation;
+        }
+
+        if ((*ki->driver->Init) (ki) != Success) {
+            return !Success;
+        }
+
+        memset(&rmlvo, 0, sizeof(rmlvo));
+        rmlvo.rules = ki->xkbRules;
+        rmlvo.model = ki->xkbModel;
+        rmlvo.layout = ki->xkbLayout;
+        rmlvo.variant = ki->xkbVariant;
+        rmlvo.options = ki->xkbOptions;
+        ret = InitKeyboardDeviceStruct (pDevice, &rmlvo, KdBell, KdKbdCtrl);
+	if (!ret) {
+            ErrorF("Couldn't initialise keyboard %s\n", ki->name);
+	    return BadImplementation;
+        }
+
+        xiclass = AtomFromName(XI_KEYBOARD);
+        AssignTypeAndName(pDevice, xiclass,
+                          ki->name ? ki->name : "Generic KDrive Keyboard");
+
+        KdResetInputMachine();
+
+        return Success;
+
+    case DEVICE_ON:
+        if (pDev->on == TRUE)
+            return Success;
+
+        if (!ki->driver->Enable)
+            return BadImplementation;
+
+        if ((*ki->driver->Enable) (ki) != Success) {
+            return BadMatch;
+        }
+
+        pDev->on = TRUE;
+        return Success;
+
+    case DEVICE_OFF:
+        if (pDev->on == FALSE)
+            return Success;
+
+        if (!ki->driver->Disable)
+            return BadImplementation;
+
+        (*ki->driver->Disable) (ki);
+        pDev->on = FALSE;
+
+        return Success;
+
+        break;
+
+    case DEVICE_CLOSE:
+	if (pDev->on) {
+            if (!ki->driver->Disable)
+                return BadImplementation;
+
+            (*ki->driver->Disable) (ki);
+            pDev->on = FALSE;
+	}
+
+        if (!ki->driver->Fini)
+            return BadImplementation;
+
+        (*ki->driver->Fini) (ki);
+
+        KdRemoveKeyboard(ki);
+
+        return Success;
+    }
+
+    /* NOTREACHED */
+    return BadImplementation;
+}
+
+void
+KdAddPointerDriver (KdPointerDriver *driver)
+{
+    KdPointerDriver **prev;
+
+    if (!driver)
+        return;
+
+    for (prev = &kdPointerDrivers; *prev; prev = &(*prev)->next) {
+        if (*prev == driver)
+            return;
+    }
+    *prev = driver;
+}
+
+void
+KdRemovePointerDriver (KdPointerDriver *driver)
+{
+    KdPointerDriver *tmp;
+
+    if (!driver)
+        return;
+
+    /* FIXME remove all pointers using this driver */
+    for (tmp = kdPointerDrivers; tmp; tmp = tmp->next) {
+        if (tmp->next == driver)
+            tmp->next = driver->next;
+    }
+    if (tmp == driver)
+        tmp = NULL;
+}
+
+void
+KdAddKeyboardDriver (KdKeyboardDriver *driver)
+{
+    KdKeyboardDriver **prev;
+
+    if (!driver)
+        return;
+
+    for (prev = &kdKeyboardDrivers; *prev; prev = &(*prev)->next) {
+        if (*prev == driver)
+            return;
+    }
+    *prev = driver;
+}
+
+void
+KdRemoveKeyboardDriver (KdKeyboardDriver *driver)
+{
+    KdKeyboardDriver *tmp;
+
+    if (!driver)
+        return;
+
+    /* FIXME remove all keyboards using this driver */
+    for (tmp = kdKeyboardDrivers; tmp; tmp = tmp->next) {
+        if (tmp->next == driver)
+            tmp->next = driver->next;
+    }
+    if (tmp == driver)
+        tmp = NULL;
+}
+
+KdKeyboardInfo *
+KdNewKeyboard (void)
+{
+    KdKeyboardInfo *ki = calloc(sizeof(KdKeyboardInfo), 1);
+    if (!ki)
+        return NULL;
+
+    ki->minScanCode = 0;
+    ki->maxScanCode = 0;
+    ki->leds = 0;
+    ki->bellPitch = 1000;
+    ki->bellDuration = 200;
+    ki->next = NULL;
+    ki->options = NULL;
+    ki->xkbRules = strdup(XKB_DFLT_RULES);
+    ki->xkbModel = strdup(XKB_DFLT_MODEL);
+    ki->xkbLayout = strdup(XKB_DFLT_LAYOUT);
+    ki->xkbVariant = strdup(XKB_DFLT_VARIANT);
+    ki->xkbOptions = strdup(XKB_DFLT_OPTIONS);
+
+    return ki;
+}
+
+int
+KdAddConfigKeyboard (char *keyboard)
+{
+    struct KdConfigDevice **prev, *new;
+
+    if (!keyboard)
+        return Success;
+
+    new = (struct KdConfigDevice *) calloc(sizeof(struct KdConfigDevice), 1);
+    if (!new)
+        return BadAlloc;
+
+    new->line = strdup(keyboard);
+    new->next = NULL;
+
+    for (prev = &kdConfigKeyboards; *prev; prev = &(*prev)->next);
+    *prev = new;
+
+    return Success;
+}
+
+int
+KdAddKeyboard (KdKeyboardInfo *ki)
+{
+    KdKeyboardInfo **prev;
+
+    if (!ki)
+        return !Success;
+
+    ki->dixdev = AddInputDevice(serverClient, KdKeyboardProc, TRUE);
+    if (!ki->dixdev) {
+        ErrorF("Couldn't register keyboard device %s\n",
+               ki->name ? ki->name : "(unnamed)");
+        return !Success;
+    }
+
+#ifdef DEBUG
+    ErrorF("added keyboard %s with dix id %d\n", ki->name, ki->dixdev->id);
+#endif
+
+    for (prev = &kdKeyboards; *prev; prev = &(*prev)->next);
+    *prev = ki;
+
+    return Success;
+}
+
+void
+KdRemoveKeyboard (KdKeyboardInfo *ki)
+{
+    KdKeyboardInfo **prev;
+
+    if (!ki)
+        return;
+
+    for (prev = &kdKeyboards; *prev; prev = &(*prev)->next) {
+        if (*prev == ki) {
+            *prev = ki->next;
+            break;
+        }
+    }
+
+    KdFreeKeyboard(ki);
+}
+
+int
+KdAddConfigPointer (char *pointer)
+{
+    struct KdConfigDevice **prev, *new;
+
+    if (!pointer)
+        return Success;
+
+    new = (struct KdConfigDevice *) calloc(sizeof(struct KdConfigDevice), 1);
+    if (!new)
+        return BadAlloc;
+
+    new->line = strdup(pointer);
+    new->next = NULL;
+
+    for (prev = &kdConfigPointers; *prev; prev = &(*prev)->next);
+    *prev = new;
+
+    return Success;
+}
+
+int
+KdAddPointer (KdPointerInfo *pi)
+{
+    KdPointerInfo **prev;
+
+    if (!pi)
+        return Success;
+
+    pi->mouseState = start;
+    pi->eventHeld = FALSE;
+
+    pi->dixdev = AddInputDevice(serverClient, KdPointerProc, TRUE);
+    if (!pi->dixdev) {
+        ErrorF("Couldn't add pointer device %s\n",
+               pi->name ? pi->name : "(unnamed)");
+        return BadDevice;
+    }
+
+    for (prev = &kdPointers; *prev; prev = &(*prev)->next);
+    *prev = pi;
+
+    return Success;
+}
+
+void
+KdRemovePointer (KdPointerInfo *pi)
+{
+    KdPointerInfo **prev;
+
+    if (!pi)
+        return;
+
+    for (prev = &kdPointers; *prev; prev = &(*prev)->next) {
+        if (*prev == pi) {
+            *prev = pi->next;
+            break;
+        }
+    }
+
+    KdFreePointer(pi);
+}
+
+/*
+ * You can call your kdriver server with something like:
+ * $ ./hw/kdrive/yourserver/X :1 -mouse evdev,,device=/dev/input/event4 -keybd
+ * evdev,,device=/dev/input/event1,xkbmodel=abnt2,xkblayout=br
+ */
+static Bool
+KdGetOptions (InputOption **options, char *string)
+{
+    InputOption     *newopt = NULL, **tmpo = NULL;
+    int             tam_key = 0;
+
+    newopt = calloc(1, sizeof (InputOption));
+    if (!newopt)
+        return FALSE;
+
+    for (tmpo = options; *tmpo; tmpo = &(*tmpo)->next)
+        ; /* Hello, I'm here */
+    *tmpo = newopt;
+
+    if (strchr(string, '='))
+    {
+        tam_key = (strchr(string, '=') - string);
+        newopt->key = (char *)malloc(tam_key);
+        strncpy(newopt->key, string, tam_key);
+        newopt->key[tam_key] = '\0';
+        newopt->value = strdup(strchr(string, '=') + 1);
+    }
+    else
+    {
+        newopt->key = strdup(string);
+        newopt->value = NULL;
+    }
+    newopt->next = NULL;
+
+    return TRUE;
+}
+
+static void
+KdParseKbdOptions (KdKeyboardInfo *ki)
+{
+    InputOption *option = NULL;
+
+    for (option = ki->options; option; option = option->next)
+    {
+        if (strcasecmp(option->key, "XkbRules") == 0)
+            ki->xkbRules = option->value;
+        else if (strcasecmp(option->key, "XkbModel") == 0)
+            ki->xkbModel = option->value;
+        else if (strcasecmp(option->key, "XkbLayout") == 0)
+            ki->xkbLayout = option->value;
+        else if (strcasecmp(option->key, "XkbVariant") == 0)
+            ki->xkbVariant = option->value;
+        else if (strcasecmp(option->key, "XkbOptions") == 0)
+            ki->xkbOptions = option->value;
+        else if (!strcasecmp (option->key, "device"))
+            ki->path = strdup(option->value);
+        else
+           ErrorF("Kbd option key (%s) of value (%s) not assigned!\n",
+                    option->key, option->value);
+    }
+}
+
+KdKeyboardInfo *
+KdParseKeyboard (char *arg)
+{
+    char            save[1024];
+    char            delim;
+    InputOption     *options = NULL;
+    KdKeyboardInfo     *ki = NULL;
+
+    ki = KdNewKeyboard();
+    if (!ki)
+        return NULL;
+
+    ki->name = strdup("Unknown KDrive Keyboard");
+    ki->path = NULL;
+    ki->driver = NULL;
+    ki->driverPrivate = NULL;
+    ki->next = NULL;
+
+    if (!arg)
+    {
+        ErrorF("keybd: no arg\n");
+        KdFreeKeyboard (ki);
+        return NULL;
+    }
+
+    if (strlen (arg) >= sizeof (save))
+    {
+        ErrorF("keybd: arg too long\n");
+        KdFreeKeyboard (ki);
+        return NULL;
+    }
+
+    arg = KdParseFindNext (arg, ",", save, &delim);
+    if (!save[0])
+    {
+        ErrorF("keybd: failed on save[0]\n");
+        KdFreeKeyboard (ki);
+        return NULL;
+    }
+
+    if (strcmp (save, "auto") == 0)
+        ki->driverPrivate = NULL;
+    else
+        ki->driverPrivate = strdup(save);
+
+    if (delim != ',')
+    {
+        return ki;
+    }
+
+    arg = KdParseFindNext (arg, ",", save, &delim);
+
+    while (delim == ',')
+    {
+        arg = KdParseFindNext (arg, ",", save, &delim);
+
+	if (!KdGetOptions(&options, save))
+	{
+	    KdFreeKeyboard(ki);
+	    return NULL;
+        }
+    }
+
+    if (options)
+    {
+        ki->options = options;
+        KdParseKbdOptions(ki);
+    }
+
+    return ki;
+}
+
+static void
+KdParsePointerOptions (KdPointerInfo *pi)
+{
+    InputOption *option = NULL;
+
+    for (option = pi->options; option; option = option->next)
+    {
+        if (!strcmp (option->key, "emulatemiddle"))
+            pi->emulateMiddleButton = TRUE;
+        else if (!strcmp (option->key, "noemulatemiddle"))
+            pi->emulateMiddleButton = FALSE;
+        else if (!strcmp (option->key, "transformcoord"))
+            pi->transformCoordinates = TRUE;
+        else if (!strcmp (option->key, "rawcoord"))
+            pi->transformCoordinates = FALSE;
+        else if (!strcasecmp (option->key, "device"))
+            pi->path = strdup(option->value);
+        else if (!strcasecmp (option->key, "protocol"))
+            pi->protocol = strdup(option->value);
+        else
+            ErrorF("Pointer option key (%s) of value (%s) not assigned!\n",
+                    option->key, option->value);
+    }
+}
+
+KdPointerInfo *
+KdParsePointer (char *arg)
+{
+    char            save[1024];
+    char            delim;
+    KdPointerInfo   *pi = NULL;
+    InputOption     *options = NULL;
+    int             i = 0;
+
+    pi = KdNewPointer();
+    if (!pi)
+        return NULL;
+    pi->emulateMiddleButton = kdEmulateMiddleButton;
+    pi->transformCoordinates = !kdRawPointerCoordinates;
+    pi->protocol = NULL;
+    pi->nButtons = 5; /* XXX should not be hardcoded */
+    pi->inputClass = KD_MOUSE;
+
+    if (!arg)
+    {
+        ErrorF("mouse: no arg\n");
+        KdFreePointer (pi);
+        return NULL;
+    }
+
+    if (strlen (arg) >= sizeof (save))
+    {
+        ErrorF("mouse: arg too long\n");
+        KdFreePointer (pi);
+        return NULL;
+    }
+    arg = KdParseFindNext (arg, ",", save, &delim);
+    if (!save[0])
+    {
+        ErrorF("failed on save[0]\n");
+        KdFreePointer (pi);
+        return NULL;
+    }
+
+    if (strcmp(save, "auto") == 0)
+        pi->driverPrivate = NULL;
+    else
+        pi->driverPrivate = strdup(save);
+
+    if (delim != ',')
+    {
+        return pi;
+    }
+
+    arg = KdParseFindNext (arg, ",", save, &delim);
+
+    while (delim == ',')
+    {
+        arg = KdParseFindNext (arg, ",", save, &delim);
+        if (save[0] == '{')
+        {
+            char *s = save + 1;
+             i = 0;
+             while (*s && *s != '}')
+             {
+                if ('1' <= *s && *s <= '0' + pi->nButtons)
+                    pi->map[i] = *s - '0';
+                else
+                    UseMsg ();
+                s++;
+             }
+        }
+        else
+        {
+            if (!KdGetOptions(&options, save))
+            {
+                KdFreePointer(pi);
+                return NULL;
+            }
+        }
+    }
+
+    if (options)
+    {
+        pi->options = options;
+        KdParsePointerOptions(pi);
+    }
+
+    return pi;
+}
+
+
+void
+KdInitInput (void)
+{
+    KdPointerInfo *pi;
+    KdKeyboardInfo *ki;
+    struct KdConfigDevice *dev;
+
+    kdInputEnabled = TRUE;
+
+    for (dev = kdConfigPointers; dev; dev = dev->next) {
+        pi = KdParsePointer(dev->line);
+        if (!pi)
+            ErrorF("Failed to parse pointer\n");
+        if (KdAddPointer(pi) != Success)
+            ErrorF("Failed to add pointer!\n");
+    }
+    for (dev = kdConfigKeyboards; dev; dev = dev->next) {
+        ki = KdParseKeyboard(dev->line);
+        if (!ki)
+            ErrorF("Failed to parse keyboard\n");
+        if (KdAddKeyboard(ki) != Success)
+            ErrorF("Failed to add keyboard!\n");
+    }
+
+    mieqInit();
+}
+
+void
+KdCloseInput (void)
+{
+    mieqFini();
+}
+
+/*
+ * Middle button emulation state machine
+ *
+ *  Possible transitions:
+ *	Button 1 press	    v1
+ *	Button 1 release    ^1
+ *	Button 2 press	    v2
+ *	Button 2 release    ^2
+ *	Button 3 press	    v3
+ *	Button 3 release    ^3
+ *	Button other press  vo
+ *	Button other release ^o
+ *	Mouse motion	    <>
+ *	Keyboard event	    k
+ *	timeout		    ...
+ *	outside box	    <->
+ *
+ *  States:
+ *	start
+ *	button_1_pend
+ *	button_1_down
+ *	button_2_down
+ *	button_3_pend
+ *	button_3_down
+ *	synthetic_2_down_13
+ *	synthetic_2_down_3
+ *	synthetic_2_down_1
+ *
+ *  Transition diagram
+ *
+ *  start
+ *	v1  -> (hold) (settimeout) button_1_pend
+ *	^1  -> (deliver) start
+ *	v2  -> (deliver) button_2_down
+ *	^2  -> (deliever) start
+ *	v3  -> (hold) (settimeout) button_3_pend
+ *	^3  -> (deliver) start
+ *	vo  -> (deliver) start
+ *	^o  -> (deliver) start
+ *	<>  -> (deliver) start
+ *	k   -> (deliver) start
+ *
+ *  button_1_pend	(button 1 is down, timeout pending)
+ *	^1  -> (release) (deliver) start
+ *	v2  -> (release) (deliver) button_1_down
+ *	^2  -> (release) (deliver) button_1_down
+ *	v3  -> (cleartimeout) (generate v2) synthetic_2_down_13
+ *	^3  -> (release) (deliver) button_1_down
+ *	vo  -> (release) (deliver) button_1_down
+ *	^o  -> (release) (deliver) button_1_down
+ *	<-> -> (release) (deliver) button_1_down
+ *	<>  -> (deliver) button_1_pend
+ *	k   -> (release) (deliver) button_1_down
+ *	... -> (release) button_1_down
+ *
+ *  button_1_down	(button 1 is down)
+ *	^1  -> (deliver) start
+ *	v2  -> (deliver) button_1_down
+ *	^2  -> (deliver) button_1_down
+ *	v3  -> (deliver) button_1_down
+ *	^3  -> (deliver) button_1_down
+ *	vo  -> (deliver) button_1_down
+ *	^o  -> (deliver) button_1_down
+ *	<>  -> (deliver) button_1_down
+ *	k   -> (deliver) button_1_down
+ *
+ *  button_2_down	(button 2 is down)
+ *	v1  -> (deliver) button_2_down
+ *	^1  -> (deliver) button_2_down
+ *	^2  -> (deliver) start
+ *	v3  -> (deliver) button_2_down
+ *	^3  -> (deliver) button_2_down
+ *	vo  -> (deliver) button_2_down
+ *	^o  -> (deliver) button_2_down
+ *	<>  -> (deliver) button_2_down
+ *	k   -> (deliver) button_2_down
+ *
+ *  button_3_pend	(button 3 is down, timeout pending)
+ *	v1  -> (generate v2) synthetic_2_down
+ *	^1  -> (release) (deliver) button_3_down
+ *	v2  -> (release) (deliver) button_3_down
+ *	^2  -> (release) (deliver) button_3_down
+ *	^3  -> (release) (deliver) start
+ *	vo  -> (release) (deliver) button_3_down
+ *	^o  -> (release) (deliver) button_3_down
+ *	<-> -> (release) (deliver) button_3_down
+ *	<>  -> (deliver) button_3_pend
+ *	k   -> (release) (deliver) button_3_down
+ *	... -> (release) button_3_down
+ *
+ *  button_3_down	(button 3 is down)
+ *	v1  -> (deliver) button_3_down
+ *	^1  -> (deliver) button_3_down
+ *	v2  -> (deliver) button_3_down
+ *	^2  -> (deliver) button_3_down
+ *	^3  -> (deliver) start
+ *	vo  -> (deliver) button_3_down
+ *	^o  -> (deliver) button_3_down
+ *	<>  -> (deliver) button_3_down
+ *	k   -> (deliver) button_3_down
+ *
+ *  synthetic_2_down_13	(button 1 and 3 are down)
+ *	^1  -> (generate ^2) synthetic_2_down_3
+ *	v2  -> synthetic_2_down_13
+ *	^2  -> synthetic_2_down_13
+ *	^3  -> (generate ^2) synthetic_2_down_1
+ *	vo  -> (deliver) synthetic_2_down_13
+ *	^o  -> (deliver) synthetic_2_down_13
+ *	<>  -> (deliver) synthetic_2_down_13
+ *	k   -> (deliver) synthetic_2_down_13
+ *
+ *  synthetic_2_down_3 (button 3 is down)
+ *	v1  -> (deliver) synthetic_2_down_3
+ *	^1  -> (deliver) synthetic_2_down_3
+ *	v2  -> synthetic_2_down_3
+ *	^2  -> synthetic_2_down_3
+ *	^3  -> start
+ *	vo  -> (deliver) synthetic_2_down_3
+ *	^o  -> (deliver) synthetic_2_down_3
+ *	<>  -> (deliver) synthetic_2_down_3
+ *	k   -> (deliver) synthetic_2_down_3
+ *
+ *  synthetic_2_down_1 (button 1 is down)
+ *	^1  -> start
+ *	v2  -> synthetic_2_down_1
+ *	^2  -> synthetic_2_down_1
+ *	v3  -> (deliver) synthetic_2_down_1
+ *	^3  -> (deliver) synthetic_2_down_1
+ *	vo  -> (deliver) synthetic_2_down_1
+ *	^o  -> (deliver) synthetic_2_down_1
+ *	<>  -> (deliver) synthetic_2_down_1
+ *	k   -> (deliver) synthetic_2_down_1
+ */
+
+typedef enum _inputClass {
+    down_1, up_1,
+    down_2, up_2,
+    down_3, up_3,
+    down_o, up_o,
+    motion, outside_box,
+    keyboard, timeout,
+    num_input_class
+} KdInputClass;
+
+typedef enum _inputAction {
+    noop,
+    hold,
+    setto,
+    deliver,
+    release,
+    clearto,
+    gen_down_2,
+    gen_up_2
+} KdInputAction;
+
+#define MAX_ACTIONS 2
+
+typedef struct _inputTransition {
+    KdInputAction  actions[MAX_ACTIONS];
+    KdPointerState nextState;
+} KdInputTransition;
+
+static const
+KdInputTransition  kdInputMachine[num_input_states][num_input_class] = {
+    /* start */
+    {
+	{ { hold, setto },	    button_1_pend },	/* v1 */
+	{ { deliver, noop },	    start },		/* ^1 */
+	{ { deliver, noop },	    button_2_down },	/* v2 */
+	{ { deliver, noop },	    start },		/* ^2 */
+	{ { hold, setto },	    button_3_pend },	/* v3 */
+	{ { deliver, noop },	    start },		/* ^3 */
+	{ { deliver, noop },	    start },		/* vo */
+	{ { deliver, noop },	    start },		/* ^o */
+	{ { deliver, noop },	    start },		/* <> */
+	{ { deliver, noop },	    start },		/* <-> */
+	{ { noop, noop },	    start },		/* k */
+	{ { noop, noop },	    start },		/* ... */
+    },
+    /* button_1_pend */
+    {
+	{ { noop, noop },	    button_1_pend },	/* v1 */
+	{ { release, deliver },	    start },		/* ^1 */
+	{ { release, deliver },	    button_1_down },	/* v2 */
+	{ { release, deliver },	    button_1_down },	/* ^2 */
+	{ { clearto, gen_down_2 },  synth_2_down_13 },	/* v3 */
+	{ { release, deliver },	    button_1_down },	/* ^3 */
+	{ { release, deliver },	    button_1_down },	/* vo */
+	{ { release, deliver },	    button_1_down },	/* ^o */
+	{ { deliver, noop },	    button_1_pend },	/* <> */
+	{ { release, deliver },	    button_1_down },	/* <-> */
+	{ { noop, noop },	    button_1_down },	/* k */
+	{ { release, noop },	    button_1_down },	/* ... */
+    },
+    /* button_1_down */
+    {
+	{ { noop, noop },	    button_1_down },	/* v1 */
+	{ { deliver, noop },	    start },		/* ^1 */
+	{ { deliver, noop },	    button_1_down },	/* v2 */
+	{ { deliver, noop },	    button_1_down },	/* ^2 */
+	{ { deliver, noop },	    button_1_down },	/* v3 */
+	{ { deliver, noop },	    button_1_down },	/* ^3 */
+	{ { deliver, noop },	    button_1_down },	/* vo */
+	{ { deliver, noop },	    button_1_down },	/* ^o */
+	{ { deliver, noop },	    button_1_down },	/* <> */
+	{ { deliver, noop },	    button_1_down },	/* <-> */
+	{ { noop, noop },	    button_1_down },	/* k */
+	{ { noop, noop },	    button_1_down },	/* ... */
+    },
+    /* button_2_down */
+    {
+	{ { deliver, noop },	    button_2_down },	/* v1 */
+	{ { deliver, noop },	    button_2_down },	/* ^1 */
+	{ { noop, noop },	    button_2_down },	/* v2 */
+	{ { deliver, noop },	    start },		/* ^2 */
+	{ { deliver, noop },	    button_2_down },	/* v3 */
+	{ { deliver, noop },	    button_2_down },	/* ^3 */
+	{ { deliver, noop },	    button_2_down },	/* vo */
+	{ { deliver, noop },	    button_2_down },	/* ^o */
+	{ { deliver, noop },	    button_2_down },	/* <> */
+	{ { deliver, noop },	    button_2_down },	/* <-> */
+	{ { noop, noop },	    button_2_down },	/* k */
+	{ { noop, noop },	    button_2_down },	/* ... */
+    },
+    /* button_3_pend */
+    {
+	{ { clearto, gen_down_2 },  synth_2_down_13 },	/* v1 */
+	{ { release, deliver },	    button_3_down },	/* ^1 */
+	{ { release, deliver },	    button_3_down },	/* v2 */
+	{ { release, deliver },	    button_3_down },	/* ^2 */
+	{ { release, deliver },	    button_3_down },	/* v3 */
+	{ { release, deliver },	    start },		/* ^3 */
+	{ { release, deliver },	    button_3_down },	/* vo */
+	{ { release, deliver },	    button_3_down },	/* ^o */
+	{ { deliver, noop },	    button_3_pend },	/* <> */
+	{ { release, deliver },	    button_3_down },	/* <-> */
+	{ { release, noop },	    button_3_down },	/* k */
+	{ { release, noop },	    button_3_down },	/* ... */
+    },
+    /* button_3_down */
+    {
+	{ { deliver, noop },	    button_3_down },	/* v1 */
+	{ { deliver, noop },	    button_3_down },	/* ^1 */
+	{ { deliver, noop },	    button_3_down },	/* v2 */
+	{ { deliver, noop },	    button_3_down },	/* ^2 */
+	{ { noop, noop },	    button_3_down },	/* v3 */
+	{ { deliver, noop },	    start },		/* ^3 */
+	{ { deliver, noop },	    button_3_down },	/* vo */
+	{ { deliver, noop },	    button_3_down },	/* ^o */
+	{ { deliver, noop },	    button_3_down },	/* <> */
+	{ { deliver, noop },	    button_3_down },	/* <-> */
+	{ { noop, noop },	    button_3_down },	/* k */
+	{ { noop, noop },	    button_3_down },	/* ... */
+    },
+    /* synthetic_2_down_13 */
+    {
+	{ { noop, noop },	    synth_2_down_13 },	/* v1 */
+	{ { gen_up_2, noop },	    synth_2_down_3 },	/* ^1 */
+	{ { noop, noop },	    synth_2_down_13 },	/* v2 */
+	{ { noop, noop },	    synth_2_down_13 },	/* ^2 */
+	{ { noop, noop },	    synth_2_down_13 },	/* v3 */
+	{ { gen_up_2, noop },	    synth_2_down_1 },	/* ^3 */
+	{ { deliver, noop },	    synth_2_down_13 },	/* vo */
+	{ { deliver, noop },	    synth_2_down_13 },	/* ^o */
+	{ { deliver, noop },	    synth_2_down_13 },	/* <> */
+	{ { deliver, noop },	    synth_2_down_13 },	/* <-> */
+	{ { noop, noop },	    synth_2_down_13 },	/* k */
+	{ { noop, noop },	    synth_2_down_13 },	/* ... */
+    },
+    /* synthetic_2_down_3 */
+    {
+	{ { deliver, noop },	    synth_2_down_3 },	/* v1 */
+	{ { deliver, noop },	    synth_2_down_3 },	/* ^1 */
+	{ { deliver, noop },	    synth_2_down_3 },	/* v2 */
+	{ { deliver, noop },	    synth_2_down_3 },	/* ^2 */
+	{ { noop, noop },	    synth_2_down_3 },	/* v3 */
+	{ { noop, noop },	    start },		/* ^3 */
+	{ { deliver, noop },	    synth_2_down_3 },	/* vo */
+	{ { deliver, noop },	    synth_2_down_3 },	/* ^o */
+	{ { deliver, noop },	    synth_2_down_3 },	/* <> */
+	{ { deliver, noop },	    synth_2_down_3 },	/* <-> */
+	{ { noop, noop },	    synth_2_down_3 },	/* k */
+	{ { noop, noop },	    synth_2_down_3 },	/* ... */
+    },
+    /* synthetic_2_down_1 */
+    {
+	{ { noop, noop },	    synth_2_down_1 },	/* v1 */
+	{ { noop, noop },	    start },		/* ^1 */
+	{ { deliver, noop },	    synth_2_down_1 },	/* v2 */
+	{ { deliver, noop },	    synth_2_down_1 },	/* ^2 */
+	{ { deliver, noop },	    synth_2_down_1 },	/* v3 */
+	{ { deliver, noop },	    synth_2_down_1 },	/* ^3 */
+	{ { deliver, noop },	    synth_2_down_1 },	/* vo */
+	{ { deliver, noop },	    synth_2_down_1 },	/* ^o */
+	{ { deliver, noop },	    synth_2_down_1 },	/* <> */
+	{ { deliver, noop },	    synth_2_down_1 },	/* <-> */
+	{ { noop, noop },	    synth_2_down_1 },	/* k */
+	{ { noop, noop },	    synth_2_down_1 },	/* ... */
+    },
+};
+
+#define EMULATION_WINDOW    10
+#define EMULATION_TIMEOUT   100
+
+static int
+KdInsideEmulationWindow (KdPointerInfo *pi, int x, int y, int z)
+{
+    pi->emulationDx = pi->heldEvent.x - x;
+    pi->emulationDy = pi->heldEvent.y - y;
+
+    return (abs (pi->emulationDx) < EMULATION_WINDOW &&
+	    abs (pi->emulationDy) < EMULATION_WINDOW);
+}
+
+static KdInputClass
+KdClassifyInput (KdPointerInfo *pi, int type, int x, int y, int z, int b)
+{
+    switch (type) {
+    case ButtonPress:
+	switch (b) {
+	case 1: return down_1;
+	case 2: return down_2;
+	case 3: return down_3;
+	default: return down_o;
+	}
+	break;
+    case ButtonRelease:
+	switch (b) {
+	case 1: return up_1;
+	case 2: return up_2;
+	case 3: return up_3;
+	default: return up_o;
+	}
+	break;
+    case MotionNotify:
+	if (pi->eventHeld && !KdInsideEmulationWindow(pi, x, y, z))
+	    return outside_box;
+	else
+	    return motion;
+    default:
+	return keyboard;
+    }
+    return keyboard;
+}
+
+#ifdef DEBUG
+char	*kdStateNames[] = {
+    "start",
+    "button_1_pend",
+    "button_1_down",
+    "button_2_down",
+    "button_3_pend",
+    "button_3_down",
+    "synth_2_down_13",
+    "synth_2_down_3",
+    "synthetic_2_down_1",
+    "num_input_states"
+};
+
+char	*kdClassNames[] = {
+    "down_1", "up_1",
+    "down_2", "up_2",
+    "down_3", "up_3",
+    "motion", "ouside_box",
+    "keyboard", "timeout",
+    "num_input_class"
+};
+
+char *kdActionNames[] = {
+    "noop",
+    "hold",
+    "setto",
+    "deliver",
+    "release",
+    "clearto",
+    "gen_down_2",
+    "gen_up_2",
+};
+#endif /* DEBUG */
+
+static void
+KdQueueEvent (DeviceIntPtr pDev, InternalEvent *ev)
+{
+    KdAssertSigioBlocked ("KdQueueEvent");
+    mieqEnqueue (pDev, ev);
+}
+
+/* We return true if we're stealing the event. */
+static Bool
+KdRunMouseMachine (KdPointerInfo *pi, KdInputClass c, int type, int x, int y,
+                   int z, int b, int absrel)
+{
+    const KdInputTransition *t;
+    int	a;
+
+    c = KdClassifyInput(pi, type, x, y, z, b);
+    t = &kdInputMachine[pi->mouseState][c];
+    for (a = 0; a < MAX_ACTIONS; a++)
+    {
+	switch (t->actions[a]) {
+	case noop:
+	    break;
+	case hold:
+	    pi->eventHeld = TRUE;
+	    pi->emulationDx = 0;
+	    pi->emulationDy = 0;
+	    pi->heldEvent.type = type;
+            pi->heldEvent.x = x;
+            pi->heldEvent.y = y;
+            pi->heldEvent.z = z;
+            pi->heldEvent.flags = b;
+            pi->heldEvent.absrel = absrel;
+            return TRUE;
+	    break;
+	case setto:
+	    pi->emulationTimeout = GetTimeInMillis () + EMULATION_TIMEOUT;
+	    pi->timeoutPending = TRUE;
+	    break;
+	case deliver:
+            _KdEnqueuePointerEvent (pi, pi->heldEvent.type, pi->heldEvent.x,
+                                    pi->heldEvent.y, pi->heldEvent.z,
+                                    pi->heldEvent.flags, pi->heldEvent.absrel,
+                                    TRUE);
+	    break;
+	case release:
+	    pi->eventHeld = FALSE;
+	    pi->timeoutPending = FALSE;
+            _KdEnqueuePointerEvent (pi, pi->heldEvent.type, pi->heldEvent.x,
+                                    pi->heldEvent.y, pi->heldEvent.z,
+                                    pi->heldEvent.flags, pi->heldEvent.absrel,
+                                    TRUE);
+            return TRUE;
+	    break;
+	case clearto:
+	    pi->timeoutPending = FALSE;
+	    break;
+	case gen_down_2:
+            _KdEnqueuePointerEvent (pi, ButtonPress, x, y, z, 2, absrel,
+                                    TRUE);
+	    pi->eventHeld = FALSE;
+            return TRUE;
+	    break;
+	case gen_up_2:
+            _KdEnqueuePointerEvent (pi, ButtonRelease, x, y, z, 2, absrel,
+                                    TRUE);
+            return TRUE;
+	    break;
+	}
+    }
+    pi->mouseState = t->nextState;
+    return FALSE;
+}
+
+static int
+KdHandlePointerEvent (KdPointerInfo *pi, int type, int x, int y, int z, int b,
+                      int absrel)
+{
+    if (pi->emulateMiddleButton)
+        return KdRunMouseMachine (pi, KdClassifyInput(pi, type, x, y, z, b),
+                                  type, x, y, z, b, absrel);
+    return FALSE;
+}
+
+static void
+KdReceiveTimeout (KdPointerInfo *pi)
+{
+    KdRunMouseMachine (pi, timeout, 0, 0, 0, 0, 0, 0);
+}
+
+/*
+ * kdCheckTermination
+ *
+ * This function checks for the key sequence that terminates the server.  When
+ * detected, it sets the dispatchException flag and returns.  The key sequence
+ * is:
+ *	Control-Alt
+ * It's assumed that the server will be waken up by the caller when this
+ * function returns.
+ */
+
+extern int nClients;
+
+void
+KdReleaseAllKeys (void)
+{
+#if 0
+    int	key;
+    KdKeyboardInfo *ki;
+
+    KdBlockSigio ();
+
+    for (ki = kdKeyboards; ki; ki = ki->next) {
+        for (key = ki->keySyms.minKeyCode; key < ki->keySyms.maxKeyCode;
+             key++) {
+            if (key_is_down(ki->dixdev, key, KEY_POSTED | KEY_PROCESSED)) {
+                KdHandleKeyboardEvent(ki, KeyRelease, key);
+                QueueGetKeyboardEvents(ki->dixdev, KeyRelease, key, NULL);
+            }
+        }
+    }
+
+    KdUnblockSigio ();
+#endif
+}
+
+static void
+KdCheckLock (void)
+{
+    KeyClassPtr	    keyc = NULL;
+    Bool	    isSet = FALSE, shouldBeSet = FALSE;
+    KdKeyboardInfo     *tmp = NULL;
+
+    for (tmp = kdKeyboards; tmp; tmp = tmp->next) {
+        if (tmp->LockLed && tmp->dixdev && tmp->dixdev->key) {
+            keyc = tmp->dixdev->key;
+            isSet = (tmp->leds & (1 << (tmp->LockLed-1))) != 0;
+            /* FIXME: Just use XKB indicators! */
+            shouldBeSet = !!(XkbStateFieldFromRec(&keyc->xkbInfo->state) & LockMask);
+            if (isSet != shouldBeSet)
+                KdSetLed (tmp, tmp->LockLed, shouldBeSet);
+        }
+    }
+}
+
+void
+KdEnqueueKeyboardEvent(KdKeyboardInfo   *ki,
+                       unsigned char scan_code,
+		       unsigned char is_up)
+{
+    unsigned char key_code;
+    KeyClassPtr	keyc = NULL;
+    KeybdCtrl *ctrl = NULL;
+    int type;
+
+    if (!ki || !ki->dixdev || !ki->dixdev->kbdfeed || !ki->dixdev->key)
+	return;
+
+    keyc = ki->dixdev->key;
+    ctrl = &ki->dixdev->kbdfeed->ctrl;
+
+    if (scan_code >= ki->minScanCode && scan_code <= ki->maxScanCode)
+    {
+	key_code = scan_code + KD_MIN_KEYCODE - ki->minScanCode;
+
+	/*
+	 * Set up this event -- the type may be modified below
+	 */
+	if (is_up)
+	    type = KeyRelease;
+	else
+	    type = KeyPress;
+
+        QueueKeyboardEvents(ki->dixdev, type, key_code, NULL);
+    }
+    else {
+        ErrorF("driver %s wanted to post scancode %d outside of [%d, %d]!\n",
+               ki->name, scan_code, ki->minScanCode, ki->maxScanCode);
+    }
+}
+
+/*
+ * kdEnqueuePointerEvent
+ *
+ * This function converts hardware mouse event information into X event
+ * information.  A mouse movement event is passed off to MI to generate
+ * a MotionNotify event, if appropriate.  Button events are created and
+ * passed off to MI for enqueueing.
+ */
+
+/* FIXME do something a little more clever to deal with multiple axes here */
+void
+KdEnqueuePointerEvent(KdPointerInfo *pi, unsigned long flags, int rx, int ry,
+                      int rz)
+{
+    CARD32        ms;
+    unsigned char buttons;
+    int           x, y, z;
+    int           (*matrix)[3] = kdPointerMatrix.matrix;
+    unsigned long button;
+    int           n;
+    int           dixflags = 0;
+
+    if (!pi)
+	return;
+
+    ms = GetTimeInMillis();
+
+    /* we don't need to transform z, so we don't. */
+    if (flags & KD_MOUSE_DELTA) {
+	if (pi->transformCoordinates) {
+	    x = matrix[0][0] * rx + matrix[0][1] * ry;
+	    y = matrix[1][0] * rx + matrix[1][1] * ry;
+	}
+	else {
+	    x = rx;
+	    y = ry;
+	}
+    }
+    else {
+	if (pi->transformCoordinates) {
+	    x = matrix[0][0] * rx + matrix[0][1] * ry + matrix[0][2];
+	    y = matrix[1][0] * rx + matrix[1][1] * ry + matrix[1][2];
+	}
+	else {
+	    x = rx;
+	    y = ry;
+	}
+    }
+    z = rz;
+
+    if (flags & KD_MOUSE_DELTA)
+    {
+        if (x || y || z)
+        {
+            dixflags = POINTER_RELATIVE | POINTER_ACCELERATE;
+            _KdEnqueuePointerEvent(pi, MotionNotify, x, y, z, 0, dixflags, FALSE);
+        }
+    } else
+    {
+        dixflags = POINTER_ABSOLUTE;
+        if (x != pi->dixdev->last.valuators[0] ||
+            y != pi->dixdev->last.valuators[1])
+            _KdEnqueuePointerEvent(pi, MotionNotify, x, y, z, 0, dixflags, FALSE);
+    }
+
+    buttons = flags;
+
+    for (button = KD_BUTTON_1, n = 1; n <= pi->nButtons;
+         button <<= 1, n++) {
+        if (((pi->buttonState & button) ^ (buttons & button)) &&
+           !(buttons & button)) {
+            _KdEnqueuePointerEvent(pi, ButtonRelease, x, y, z, n,
+                                   dixflags, FALSE);
+	}
+    }
+    for (button = KD_BUTTON_1, n = 1; n <= pi->nButtons;
+         button <<= 1, n++) {
+	if (((pi->buttonState & button) ^ (buttons & button)) &&
+	    (buttons & button)) {
+            _KdEnqueuePointerEvent(pi, ButtonPress, x, y, z, n,
+                                   dixflags, FALSE);
+        }
+    }
+
+    pi->buttonState = buttons;
+}
+
+void
+_KdEnqueuePointerEvent (KdPointerInfo *pi, int type, int x, int y, int z,
+                        int b, int absrel, Bool force)
+{
+    int valuators[3] = { x, y, z };
+    ValuatorMask mask;
+
+    /* TRUE from KdHandlePointerEvent, means 'we swallowed the event'. */
+    if (!force && KdHandlePointerEvent(pi, type, x, y, z, b, absrel))
+        return;
+
+    valuator_mask_set_range(&mask, 0, 3, valuators);
+
+    QueuePointerEvents(pi->dixdev, type, b, absrel, &mask);
+}
+
+void
+KdBlockHandler (int		screen,
+		pointer		blockData,
+		pointer		timeout,
+		pointer		readmask)
+{
+    KdPointerInfo		    *pi;
+    int myTimeout=0;
+
+    for (pi = kdPointers; pi; pi = pi->next)
+    {
+	if (pi->timeoutPending)
+	{
+	    int	ms;
+
+	    ms = pi->emulationTimeout - GetTimeInMillis ();
+	    if (ms < 1)
+		ms = 1;
+	    if(ms<myTimeout || myTimeout==0)
+		    myTimeout=ms;
+	}
+    }
+    /* if we need to poll for events, do that */
+    if(kdOsFuncs->pollEvents)
+    {
+	    (*kdOsFuncs->pollEvents)();
+	    myTimeout=20;
+    }
+    if(myTimeout>0)
+    	AdjustWaitForDelay (timeout, myTimeout);
+}
+
+void
+KdWakeupHandler (int		screen,
+		 pointer    	data,
+		 unsigned long	lresult,
+		 pointer	readmask)
+{
+    int		result = (int) lresult;
+    fd_set	*pReadmask = (fd_set *) readmask;
+    int		i;
+    KdPointerInfo	*pi;
+
+    if (kdInputEnabled && result > 0)
+    {
+	for (i = 0; i < kdNumInputFds; i++)
+	    if (FD_ISSET (kdInputFds[i].fd, pReadmask))
+	    {
+		KdBlockSigio ();
+		(*kdInputFds[i].read) (kdInputFds[i].fd, kdInputFds[i].closure);
+		KdUnblockSigio ();
+	    }
+    }
+    for (pi = kdPointers; pi; pi = pi->next)
+    {
+	if (pi->timeoutPending)
+	{
+	    if ((long) (GetTimeInMillis () - pi->emulationTimeout) >= 0)
+	    {
+		pi->timeoutPending = FALSE;
+		KdBlockSigio ();
+		KdReceiveTimeout (pi);
+		KdUnblockSigio ();
+	    }
+	}
+    }
+    if (kdSwitchPending)
+	KdProcessSwitch ();
+}
+
+#define KdScreenOrigin(pScreen) (&(KdGetScreenPriv(pScreen)->screen->origin))
+
+static Bool
+KdCursorOffScreen(ScreenPtr *ppScreen, int *x, int *y)
+{
+    ScreenPtr	pScreen  = *ppScreen;
+    ScreenPtr	pNewScreen;
+    int		n;
+    int		dx, dy;
+    int		best_x, best_y;
+    int		n_best_x, n_best_y;
+    CARD32	ms;
+
+    if (kdDisableZaphod || screenInfo.numScreens <= 1)
+	return FALSE;
+
+    if (0 <= *x && *x < pScreen->width && 0 <= *y && *y < pScreen->height)
+	return FALSE;
+
+    ms = GetTimeInMillis ();
+    if (kdOffScreen && (int) (ms - kdOffScreenTime) < 1000)
+	return FALSE;
+    kdOffScreen = TRUE;
+    kdOffScreenTime = ms;
+    n_best_x = -1;
+    best_x = 32767;
+    n_best_y = -1;
+    best_y = 32767;
+    for (n = 0; n < screenInfo.numScreens; n++)
+    {
+	pNewScreen = screenInfo.screens[n];
+	if (pNewScreen == pScreen)
+	    continue;
+	dx = KdScreenOrigin(pNewScreen)->x - KdScreenOrigin(pScreen)->x;
+	dy = KdScreenOrigin(pNewScreen)->y - KdScreenOrigin(pScreen)->y;
+	if (*x < 0)
+	{
+	    if (dx <= 0 && -dx < best_x)
+	    {
+		best_x = -dx;
+		n_best_x = n;
+	    }
+	}
+	else if (*x >= pScreen->width)
+	{
+	    if (dx >= 0 && dx < best_x)
+	    {
+		best_x = dx;
+		n_best_x = n;
+	    }
+	}
+	if (*y < 0)
+	{
+	    if (dy <= 0 && -dy < best_y)
+	    {
+		best_y = -dy;
+		n_best_y = n;
+	    }
+	}
+	else if (*y >= pScreen->height)
+	{
+	    if (dy >= 0 && dy < best_y)
+	    {
+		best_y = dy;
+		n_best_y = n;
+	    }
+	}
+    }
+    if (best_y < best_x)
+	n_best_x = n_best_y;
+    if (n_best_x == -1)
+	return FALSE;
+    pNewScreen = screenInfo.screens[n_best_x];
+
+    if (*x < 0)
+	*x += pNewScreen->width;
+    if (*y < 0)
+	*y += pNewScreen->height;
+
+    if (*x >= pScreen->width)
+	*x -= pScreen->width;
+    if (*y >= pScreen->height)
+	*y -= pScreen->height;
+
+    *ppScreen = pNewScreen;
+    return TRUE;
+}
+
+static void
+KdCrossScreen(ScreenPtr pScreen, Bool entering)
+{
+#ifndef XIPAQ
+    if (entering)
+	KdEnableScreen (pScreen);
+    else
+	KdDisableScreen (pScreen);
+#endif
+}
+
+int KdCurScreen;	/* current event screen */
+
+static void
+KdWarpCursor (DeviceIntPtr pDev, ScreenPtr pScreen, int x, int y)
+{
+    KdBlockSigio ();
+    KdCurScreen = pScreen->myNum;
+    miPointerWarpCursor(pDev, pScreen, x, y);
+    KdUnblockSigio ();
+}
+
+miPointerScreenFuncRec kdPointerScreenFuncs =
+{
+    KdCursorOffScreen,
+    KdCrossScreen,
+    KdWarpCursor
+};
+
+#ifndef _MSC_VER
+void
+ProcessInputEvents (void)
+{
+    mieqProcessInputEvents();
+    if (kdSwitchPending)
+	KdProcessSwitch ();
+    KdCheckLock ();
+}
+#endif
+
+/* At the moment, absolute/relative is up to the client. */
+int
+SetDeviceMode(register ClientPtr client, DeviceIntPtr pDev, int mode)
+{
+    return BadMatch;
+}
+
+int
+SetDeviceValuators(register ClientPtr client, DeviceIntPtr pDev,
+                   int *valuators, int first_valuator, int num_valuators)
+{
+    return BadMatch;
+}
+
+int
+ChangeDeviceControl(register ClientPtr client, DeviceIntPtr pDev,
+                        xDeviceCtl *control)
+{
+    switch (control->control) {
+    case DEVICE_RESOLUTION:
+        /* FIXME do something more intelligent here */
+        return BadMatch;
+
+    case DEVICE_ABS_CALIB:
+    case DEVICE_ABS_AREA:
+    case DEVICE_CORE:
+        return BadMatch;
+    case DEVICE_ENABLE:
+        return Success;
+
+    default:
+        return BadMatch;
+    }
+
+    /* NOTREACHED */
+    return BadImplementation;
+}
+
+int
+NewInputDeviceRequest(InputOption *options, InputAttributes *attrs,
+                      DeviceIntPtr *pdev)
+{
+    InputOption *option = NULL;
+    KdPointerInfo *pi = NULL;
+    KdKeyboardInfo *ki = NULL;
+
+    for (option = options; option; option = option->next) {
+        if (strcmp(option->key, "type") == 0) {
+            if (strcmp(option->value, "pointer") == 0) {
+                pi = KdNewPointer();
+                if (!pi)
+                    return BadAlloc;
+            }
+            else if (strcmp(option->value, "keyboard") == 0) {
+                ki = KdNewKeyboard();
+                if (!ki)
+                    return BadAlloc;
+            }
+            else {
+                ErrorF("unrecognised device type!\n");
+                return BadValue;
+            }
+        }
+#ifdef CONFIG_HAL
+        else if (strcmp(option->key, "_source") == 0 &&
+                 strcmp(option->value, "server/hal") == 0)
+        {
+            ErrorF("Ignoring device from HAL.\n");
+            return BadValue;
+        }
+#endif
+#ifdef CONFIG_UDEV
+        else if (strcmp(option->key, "_source") == 0 &&
+                 strcmp(option->value, "server/udev") == 0)
+        {
+            ErrorF("Ignoring device from udev.\n");
+            return BadValue;
+        }
+#endif
+    }
+
+    if (!ki && !pi) {
+        ErrorF("unrecognised device identifier!\n");
+        return BadValue;
+    }
+
+    /* FIXME: change this code below to use KdParseKbdOptions and
+     * KdParsePointerOptions */
+    for (option = options; option; option = option->next) {
+        if (strcmp(option->key, "device") == 0) {
+            if (pi && option->value)
+                pi->path = strdup(option->value);
+            else if (ki && option->value)
+                ki->path = strdup(option->value);
+        }
+        else if (strcmp(option->key, "driver") == 0) {
+            if (pi) {
+                pi->driver = KdFindPointerDriver(option->value);
+                if (!pi->driver) {
+                    ErrorF("couldn't find driver!\n");
+                    KdFreePointer(pi);
+                    return BadValue;
+                }
+                pi->options = options;
+            }
+            else if (ki) {
+                ki->driver = KdFindKeyboardDriver(option->value);
+                if (!ki->driver) {
+                    ErrorF("couldn't find driver!\n");
+                    KdFreeKeyboard(ki);
+                    return BadValue;
+                }
+                ki->options = options;
+            }
+        }
+    }
+
+    if (pi) {
+        if (KdAddPointer(pi) != Success ||
+            ActivateDevice(pi->dixdev, TRUE) != Success ||
+            EnableDevice(pi->dixdev, TRUE) != TRUE) {
+            ErrorF("couldn't add or enable pointer\n");
+            return BadImplementation;
+        }
+    }
+    else if (ki) {
+        if (KdAddKeyboard(ki) != Success ||
+            ActivateDevice(ki->dixdev, TRUE) != Success ||
+            EnableDevice(ki->dixdev, TRUE) != TRUE) {
+            ErrorF("couldn't add or enable keyboard\n");
+            return BadImplementation;
+        }
+    }
+
+    if (pi) {
+        *pdev = pi->dixdev;
+    } else if(ki) {
+        *pdev = ki->dixdev;
+    }
+
+    return Success;
+}
+
+void
+DeleteInputDeviceRequest(DeviceIntPtr pDev)
+{
+    RemoveDevice(pDev, TRUE);
+}